fix: Restore all files lost during destructive rebase
A previous `git pull --rebase origin main` dropped 177 local commits,
losing 3400+ files across admin-v2, backend, studio-v2, website,
klausur-service, and many other services. The partial restore attempt
(660295e2) only recovered some files.
This commit restores all missing files from pre-rebase ref 98933f5e
while preserving post-rebase additions (night-scheduler, night-mode UI,
NightModeWidget dashboard integration).
Restored features include:
- AI Module Sidebar (FAB), OCR Labeling, OCR Compare
- GPU Dashboard, RAG Pipeline, Magic Help
- Klausur-Korrektur (8 files), Abitur-Archiv (5+ files)
- Companion, Zeugnisse-Crawler, Screen Flow
- Full backend, studio-v2, website, klausur-service
- All compliance SDKs, agent-core, voice-service
- CI/CD configs, documentation, scripts
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Benjamin Admin
510
backend/alerts_agent/api/routes.py
Normal file
510
backend/alerts_agent/api/routes.py
Normal file
@@ -0,0 +1,510 @@
|
||||
"""
|
||||
API Routes für Alerts Agent.
|
||||
|
||||
Endpoints:
|
||||
- POST /alerts/ingest - Manuell Alerts importieren
|
||||
- POST /alerts/run - Scoring Pipeline starten
|
||||
- GET /alerts/inbox - Inbox Items abrufen
|
||||
- POST /alerts/feedback - Relevanz-Feedback geben
|
||||
- GET /alerts/profile - User Relevance Profile
|
||||
- PUT /alerts/profile - Profile aktualisieren
|
||||
"""
|
||||
|
||||
import os
|
||||
from datetime import datetime
|
||||
from typing import Optional
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from ..models.alert_item import AlertItem, AlertStatus
|
||||
from ..models.relevance_profile import RelevanceProfile, PriorityItem
|
||||
from ..processing.relevance_scorer import RelevanceDecision, RelevanceScorer
|
||||
|
||||
|
||||
router = APIRouter(prefix="/alerts", tags=["alerts"])
|
||||
|
||||
# LLM Scorer Konfiguration aus Umgebungsvariablen
|
||||
LLM_GATEWAY_URL = os.getenv("LLM_GATEWAY_URL", "http://localhost:8000/llm")
|
||||
LLM_API_KEY = os.getenv("LLM_API_KEYS", "").split(",")[0] if os.getenv("LLM_API_KEYS") else ""
|
||||
ALERTS_USE_LLM = os.getenv("ALERTS_USE_LLM", "false").lower() == "true"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# In-Memory Storage (später durch DB ersetzen)
|
||||
# ============================================================================
|
||||
|
||||
_alerts_store: dict[str, AlertItem] = {}
|
||||
_profile_store: dict[str, RelevanceProfile] = {}
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Request/Response Models
|
||||
# ============================================================================
|
||||
|
||||
class AlertIngestRequest(BaseModel):
|
||||
"""Request für manuelles Alert-Import."""
|
||||
title: str = Field(..., min_length=1, max_length=500)
|
||||
url: str = Field(..., min_length=1)
|
||||
snippet: Optional[str] = Field(default=None, max_length=2000)
|
||||
topic_label: str = Field(default="Manual Import")
|
||||
published_at: Optional[datetime] = None
|
||||
|
||||
|
||||
class AlertIngestResponse(BaseModel):
|
||||
"""Response für Alert-Import."""
|
||||
id: str
|
||||
status: str
|
||||
message: str
|
||||
|
||||
|
||||
class AlertRunRequest(BaseModel):
|
||||
"""Request für Scoring-Pipeline."""
|
||||
limit: int = Field(default=50, ge=1, le=200)
|
||||
skip_scored: bool = Field(default=True)
|
||||
|
||||
|
||||
class AlertRunResponse(BaseModel):
|
||||
"""Response für Scoring-Pipeline."""
|
||||
processed: int
|
||||
keep: int
|
||||
drop: int
|
||||
review: int
|
||||
errors: int
|
||||
duration_ms: int
|
||||
|
||||
|
||||
class InboxItem(BaseModel):
|
||||
"""Ein Item in der Inbox."""
|
||||
id: str
|
||||
title: str
|
||||
url: str
|
||||
snippet: Optional[str]
|
||||
topic_label: str
|
||||
published_at: Optional[datetime]
|
||||
relevance_score: Optional[float]
|
||||
relevance_decision: Optional[str]
|
||||
relevance_summary: Optional[str]
|
||||
status: str
|
||||
|
||||
|
||||
class InboxResponse(BaseModel):
|
||||
"""Response für Inbox-Abfrage."""
|
||||
items: list[InboxItem]
|
||||
total: int
|
||||
page: int
|
||||
page_size: int
|
||||
|
||||
|
||||
class FeedbackRequest(BaseModel):
|
||||
"""Request für Relevanz-Feedback."""
|
||||
alert_id: str
|
||||
is_relevant: bool
|
||||
reason: Optional[str] = None
|
||||
tags: list[str] = Field(default_factory=list)
|
||||
|
||||
|
||||
class FeedbackResponse(BaseModel):
|
||||
"""Response für Feedback."""
|
||||
success: bool
|
||||
message: str
|
||||
profile_updated: bool
|
||||
|
||||
|
||||
class ProfilePriorityRequest(BaseModel):
|
||||
"""Priority für Profile-Update."""
|
||||
label: str
|
||||
weight: float = Field(default=0.5, ge=0.0, le=1.0)
|
||||
keywords: list[str] = Field(default_factory=list)
|
||||
description: Optional[str] = None
|
||||
|
||||
|
||||
class ProfileUpdateRequest(BaseModel):
|
||||
"""Request für Profile-Update."""
|
||||
priorities: Optional[list[ProfilePriorityRequest]] = None
|
||||
exclusions: Optional[list[str]] = None
|
||||
policies: Optional[dict] = None
|
||||
|
||||
|
||||
class ProfileResponse(BaseModel):
|
||||
"""Response für Profile."""
|
||||
id: str
|
||||
priorities: list[dict]
|
||||
exclusions: list[str]
|
||||
policies: dict
|
||||
total_scored: int
|
||||
total_kept: int
|
||||
total_dropped: int
|
||||
accuracy_estimate: Optional[float]
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Endpoints
|
||||
# ============================================================================
|
||||
|
||||
@router.post("/ingest", response_model=AlertIngestResponse)
|
||||
async def ingest_alert(request: AlertIngestRequest):
|
||||
"""
|
||||
Manuell einen Alert importieren.
|
||||
|
||||
Nützlich für Tests oder manuelles Hinzufügen von Artikeln.
|
||||
"""
|
||||
alert = AlertItem(
|
||||
title=request.title,
|
||||
url=request.url,
|
||||
snippet=request.snippet or "",
|
||||
topic_label=request.topic_label,
|
||||
published_at=request.published_at,
|
||||
)
|
||||
|
||||
_alerts_store[alert.id] = alert
|
||||
|
||||
return AlertIngestResponse(
|
||||
id=alert.id,
|
||||
status="created",
|
||||
message=f"Alert '{alert.title[:50]}...' importiert"
|
||||
)
|
||||
|
||||
|
||||
@router.post("/run", response_model=AlertRunResponse)
|
||||
async def run_scoring_pipeline(request: AlertRunRequest):
|
||||
"""
|
||||
Scoring-Pipeline für neue Alerts starten.
|
||||
|
||||
Bewertet alle unbewerteten Alerts und klassifiziert sie
|
||||
in KEEP, DROP oder REVIEW.
|
||||
|
||||
Wenn ALERTS_USE_LLM=true, wird das LLM Gateway für Scoring verwendet.
|
||||
Sonst wird ein schnelles Keyword-basiertes Scoring durchgeführt.
|
||||
"""
|
||||
import time
|
||||
start = time.time()
|
||||
|
||||
# Alle unbewerteten Alerts holen
|
||||
alerts_to_score = [
|
||||
a for a in _alerts_store.values()
|
||||
if a.status == AlertStatus.NEW or (not request.skip_scored and a.status == AlertStatus.SCORED)
|
||||
][:request.limit]
|
||||
|
||||
if not alerts_to_score:
|
||||
return AlertRunResponse(
|
||||
processed=0, keep=0, drop=0, review=0, errors=0,
|
||||
duration_ms=int((time.time() - start) * 1000)
|
||||
)
|
||||
|
||||
keep = drop = review = errors = 0
|
||||
|
||||
# Profil für Scoring laden
|
||||
profile = _profile_store.get("default")
|
||||
if not profile:
|
||||
profile = RelevanceProfile.create_default_education_profile()
|
||||
profile.id = "default"
|
||||
_profile_store["default"] = profile
|
||||
|
||||
if ALERTS_USE_LLM and LLM_API_KEY:
|
||||
# LLM-basiertes Scoring über Gateway
|
||||
scorer = RelevanceScorer(
|
||||
gateway_url=LLM_GATEWAY_URL,
|
||||
api_key=LLM_API_KEY,
|
||||
model="breakpilot-teacher-8b",
|
||||
)
|
||||
try:
|
||||
results = await scorer.score_batch(alerts_to_score, profile=profile)
|
||||
for result in results:
|
||||
if result.error:
|
||||
errors += 1
|
||||
elif result.decision == RelevanceDecision.KEEP:
|
||||
keep += 1
|
||||
elif result.decision == RelevanceDecision.DROP:
|
||||
drop += 1
|
||||
else:
|
||||
review += 1
|
||||
finally:
|
||||
await scorer.close()
|
||||
else:
|
||||
# Fallback: Keyword-basiertes Scoring (schnell, ohne LLM)
|
||||
for alert in alerts_to_score:
|
||||
title_lower = alert.title.lower()
|
||||
snippet_lower = (alert.snippet or "").lower()
|
||||
combined = title_lower + " " + snippet_lower
|
||||
|
||||
# Ausschlüsse aus Profil prüfen
|
||||
if any(excl.lower() in combined for excl in profile.exclusions):
|
||||
alert.relevance_score = 0.15
|
||||
alert.relevance_decision = RelevanceDecision.DROP.value
|
||||
drop += 1
|
||||
# Prioritäten aus Profil prüfen
|
||||
elif any(
|
||||
p.label.lower() in combined or
|
||||
any(kw.lower() in combined for kw in (p.keywords if hasattr(p, 'keywords') else []))
|
||||
for p in profile.priorities
|
||||
):
|
||||
alert.relevance_score = 0.85
|
||||
alert.relevance_decision = RelevanceDecision.KEEP.value
|
||||
keep += 1
|
||||
else:
|
||||
alert.relevance_score = 0.55
|
||||
alert.relevance_decision = RelevanceDecision.REVIEW.value
|
||||
review += 1
|
||||
|
||||
alert.status = AlertStatus.SCORED
|
||||
|
||||
duration_ms = int((time.time() - start) * 1000)
|
||||
|
||||
return AlertRunResponse(
|
||||
processed=len(alerts_to_score),
|
||||
keep=keep,
|
||||
drop=drop,
|
||||
review=review,
|
||||
errors=errors,
|
||||
duration_ms=duration_ms,
|
||||
)
|
||||
|
||||
|
||||
@router.get("/inbox", response_model=InboxResponse)
|
||||
async def get_inbox(
|
||||
decision: Optional[str] = Query(default=None, description="Filter: KEEP, DROP, REVIEW"),
|
||||
page: int = Query(default=1, ge=1),
|
||||
page_size: int = Query(default=20, ge=1, le=100),
|
||||
):
|
||||
"""
|
||||
Inbox Items abrufen.
|
||||
|
||||
Filtert nach Relevanz-Entscheidung. Standard zeigt KEEP und REVIEW.
|
||||
"""
|
||||
# Filter Alerts
|
||||
alerts = list(_alerts_store.values())
|
||||
|
||||
if decision:
|
||||
alerts = [a for a in alerts if a.relevance_decision == decision.upper()]
|
||||
else:
|
||||
# Standard: KEEP und REVIEW zeigen
|
||||
alerts = [a for a in alerts if a.relevance_decision in ["KEEP", "REVIEW"]]
|
||||
|
||||
# Sortieren nach Score (absteigend)
|
||||
alerts.sort(key=lambda a: a.relevance_score or 0, reverse=True)
|
||||
|
||||
# Pagination
|
||||
total = len(alerts)
|
||||
start = (page - 1) * page_size
|
||||
end = start + page_size
|
||||
page_alerts = alerts[start:end]
|
||||
|
||||
items = [
|
||||
InboxItem(
|
||||
id=a.id,
|
||||
title=a.title,
|
||||
url=a.url,
|
||||
snippet=a.snippet,
|
||||
topic_label=a.topic_label,
|
||||
published_at=a.published_at,
|
||||
relevance_score=a.relevance_score,
|
||||
relevance_decision=a.relevance_decision,
|
||||
relevance_summary=a.relevance_summary,
|
||||
status=a.status.value,
|
||||
)
|
||||
for a in page_alerts
|
||||
]
|
||||
|
||||
return InboxResponse(
|
||||
items=items,
|
||||
total=total,
|
||||
page=page,
|
||||
page_size=page_size,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/feedback", response_model=FeedbackResponse)
|
||||
async def submit_feedback(request: FeedbackRequest):
|
||||
"""
|
||||
Feedback zu einem Alert geben.
|
||||
|
||||
Das Feedback wird verwendet um das Relevanzprofil zu verbessern.
|
||||
"""
|
||||
alert = _alerts_store.get(request.alert_id)
|
||||
if not alert:
|
||||
raise HTTPException(status_code=404, detail="Alert nicht gefunden")
|
||||
|
||||
# Alert Status aktualisieren
|
||||
alert.status = AlertStatus.REVIEWED
|
||||
|
||||
# Profile aktualisieren (Default-Profile für Demo)
|
||||
profile = _profile_store.get("default")
|
||||
if not profile:
|
||||
profile = RelevanceProfile.create_default_education_profile()
|
||||
profile.id = "default"
|
||||
_profile_store["default"] = profile
|
||||
|
||||
profile.update_from_feedback(
|
||||
alert_title=alert.title,
|
||||
alert_url=alert.url,
|
||||
is_relevant=request.is_relevant,
|
||||
reason=request.reason or "",
|
||||
)
|
||||
|
||||
return FeedbackResponse(
|
||||
success=True,
|
||||
message="Feedback gespeichert",
|
||||
profile_updated=True,
|
||||
)
|
||||
|
||||
|
||||
@router.get("/profile", response_model=ProfileResponse)
|
||||
async def get_profile(user_id: Optional[str] = Query(default=None)):
|
||||
"""
|
||||
Relevanz-Profil abrufen.
|
||||
|
||||
Ohne user_id wird das Default-Profil zurückgegeben.
|
||||
"""
|
||||
profile_id = user_id or "default"
|
||||
profile = _profile_store.get(profile_id)
|
||||
|
||||
if not profile:
|
||||
# Default-Profile erstellen
|
||||
profile = RelevanceProfile.create_default_education_profile()
|
||||
profile.id = profile_id
|
||||
_profile_store[profile_id] = profile
|
||||
|
||||
return ProfileResponse(
|
||||
id=profile.id,
|
||||
priorities=[p.to_dict() if isinstance(p, PriorityItem) else p
|
||||
for p in profile.priorities],
|
||||
exclusions=profile.exclusions,
|
||||
policies=profile.policies,
|
||||
total_scored=profile.total_scored,
|
||||
total_kept=profile.total_kept,
|
||||
total_dropped=profile.total_dropped,
|
||||
accuracy_estimate=profile.accuracy_estimate,
|
||||
)
|
||||
|
||||
|
||||
@router.put("/profile", response_model=ProfileResponse)
|
||||
async def update_profile(
|
||||
request: ProfileUpdateRequest,
|
||||
user_id: Optional[str] = Query(default=None),
|
||||
):
|
||||
"""
|
||||
Relevanz-Profil aktualisieren.
|
||||
|
||||
Erlaubt Anpassung von Prioritäten, Ausschlüssen und Policies.
|
||||
"""
|
||||
profile_id = user_id or "default"
|
||||
profile = _profile_store.get(profile_id)
|
||||
|
||||
if not profile:
|
||||
profile = RelevanceProfile()
|
||||
profile.id = profile_id
|
||||
|
||||
# Updates anwenden
|
||||
if request.priorities is not None:
|
||||
profile.priorities = [
|
||||
PriorityItem(
|
||||
label=p.label,
|
||||
weight=p.weight,
|
||||
keywords=p.keywords,
|
||||
description=p.description,
|
||||
)
|
||||
for p in request.priorities
|
||||
]
|
||||
|
||||
if request.exclusions is not None:
|
||||
profile.exclusions = request.exclusions
|
||||
|
||||
if request.policies is not None:
|
||||
profile.policies = request.policies
|
||||
|
||||
profile.updated_at = datetime.utcnow()
|
||||
_profile_store[profile_id] = profile
|
||||
|
||||
return ProfileResponse(
|
||||
id=profile.id,
|
||||
priorities=[p.to_dict() if isinstance(p, PriorityItem) else p
|
||||
for p in profile.priorities],
|
||||
exclusions=profile.exclusions,
|
||||
policies=profile.policies,
|
||||
total_scored=profile.total_scored,
|
||||
total_kept=profile.total_kept,
|
||||
total_dropped=profile.total_dropped,
|
||||
accuracy_estimate=profile.accuracy_estimate,
|
||||
)
|
||||
|
||||
|
||||
@router.get("/stats")
|
||||
async def get_stats():
|
||||
"""
|
||||
Statistiken über Alerts und Scoring.
|
||||
|
||||
Gibt Statistiken im Format zurück, das das Frontend erwartet:
|
||||
- total_alerts, new_alerts, kept_alerts, review_alerts, dropped_alerts
|
||||
- total_topics, active_topics, total_rules
|
||||
"""
|
||||
alerts = list(_alerts_store.values())
|
||||
total = len(alerts)
|
||||
|
||||
# Zähle nach Status und Decision
|
||||
new_alerts = sum(1 for a in alerts if a.status == AlertStatus.NEW)
|
||||
kept_alerts = sum(1 for a in alerts if a.relevance_decision == "KEEP")
|
||||
review_alerts = sum(1 for a in alerts if a.relevance_decision == "REVIEW")
|
||||
dropped_alerts = sum(1 for a in alerts if a.relevance_decision == "DROP")
|
||||
|
||||
# Topics und Rules (In-Memory hat diese nicht, aber wir geben 0 zurück)
|
||||
# Bei DB-Implementierung würden wir hier die Repositories nutzen
|
||||
total_topics = 0
|
||||
active_topics = 0
|
||||
total_rules = 0
|
||||
|
||||
# Versuche DB-Statistiken zu laden wenn verfügbar
|
||||
try:
|
||||
from alerts_agent.db import get_db
|
||||
from alerts_agent.db.repository import TopicRepository, RuleRepository
|
||||
from contextlib import contextmanager
|
||||
|
||||
# Versuche eine DB-Session zu bekommen
|
||||
db_gen = get_db()
|
||||
db = next(db_gen, None)
|
||||
if db:
|
||||
try:
|
||||
topic_repo = TopicRepository(db)
|
||||
rule_repo = RuleRepository(db)
|
||||
|
||||
all_topics = topic_repo.get_all()
|
||||
total_topics = len(all_topics)
|
||||
active_topics = len([t for t in all_topics if t.is_active])
|
||||
|
||||
all_rules = rule_repo.get_all()
|
||||
total_rules = len(all_rules)
|
||||
finally:
|
||||
try:
|
||||
next(db_gen, None)
|
||||
except StopIteration:
|
||||
pass
|
||||
except Exception:
|
||||
# DB nicht verfügbar, nutze In-Memory Defaults
|
||||
pass
|
||||
|
||||
# Berechne Durchschnittsscore
|
||||
scored_alerts = [a for a in alerts if a.relevance_score is not None]
|
||||
avg_score = sum(a.relevance_score for a in scored_alerts) / len(scored_alerts) if scored_alerts else 0.0
|
||||
|
||||
return {
|
||||
# Frontend-kompatibles Format
|
||||
"total_alerts": total,
|
||||
"new_alerts": new_alerts,
|
||||
"kept_alerts": kept_alerts,
|
||||
"review_alerts": review_alerts,
|
||||
"dropped_alerts": dropped_alerts,
|
||||
"total_topics": total_topics,
|
||||
"active_topics": active_topics,
|
||||
"total_rules": total_rules,
|
||||
"avg_score": avg_score,
|
||||
# Zusätzliche Details (Abwärtskompatibilität)
|
||||
"by_status": {
|
||||
"new": new_alerts,
|
||||
"scored": sum(1 for a in alerts if a.status == AlertStatus.SCORED),
|
||||
"reviewed": sum(1 for a in alerts if a.status == AlertStatus.REVIEWED),
|
||||
},
|
||||
"by_decision": {
|
||||
"KEEP": kept_alerts,
|
||||
"REVIEW": review_alerts,
|
||||
"DROP": dropped_alerts,
|
||||
},
|
||||
}
|
||||
Reference in New Issue
Block a user