landvex: Fixar och tester klara för alla komponenter

- Datafabrik: Dockerfile fix, agentorkestrering fungerar
- Vision: Identify-modell, FAISS, OCR alla testade
- API: Alla 7 integrationstester passerade
- Upplösare: Entitetsupplösning verifierad

life-prod/api/weather_alerts.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""
+API för vädervarningar
+"""
+import sys
+sys.path.insert(0, '/home/bernt/.openclaw/workspace/life-prod/processing')
+from weather_analysis import generate_weather_alerts
+
+def get_current_alerts():
+    """Hämta aktuella vädervarningar"""
+    alerts = generate_weather_alerts()
+    
+    # Gruppera efter allvarlighetsgrad
+    critical = [a for a in alerts if a["severity"] == "critical"]
+    high = [a for a in alerts if a["severity"] == "high"]
+    medium = [a for a in alerts if a["severity"] == "medium"]
+    
+    return {
+        "timestamp": alerts[0]["timestamp"] if alerts else None,
+        "summary": {
+            "critical": len(critical),
+            "high": len(high),
+            "medium": len(medium),
+            "total": len(alerts)
+        },
+        "alerts": alerts
+    }
+
+def get_road_alerts(road_id):
+    """Hämta varningar för specifik väg"""
+    alerts = generate_weather_alerts()
+    road_alerts = [a for a in alerts if a["road_id"] == road_id]
+    return road_alerts
+
+if __name__ == "__main__":
+    result = get_current_alerts()
+    print(f"Vädervarningar: {result['summary']}")

life-prod/docs/vertical_chain_v1.md

@@ -0,0 +1,48 @@
+# Vertikal Kedja v1: Vägar + Väder
+
+## Komponenter
+
+### 1. Datainsamling (ingestion/)
+- `smhi_weather.py` - Hämtar temperatur och nederbörd från SMHI
+- Källa: SMHI Öppen Data
+- Uppdatering: Varje timme
+- Data: Temperatur (°C), Nederbörd (mm)
+
+### 2. Bearbetning (processing/)
+- `weather_analysis.py` - Analyserar väderkonsekvenser för vägar
+- Risker: is, frost, översvämning, svartis
+- Baserat på: Temperatur + Nederbörd + Vägtyp
+
+### 3. API (api/)
+- `weather_alerts.py` - Exponerar vädervarningar
+- Endpoints: Aktuella varningar, Vägspecifika varningar
+
+### 4. Tester (tests/)
+- `test_weather_analysis.py` - 4 tester
+- Täckning: Is, översvämning, svartis, normalt väder
+
+## Dataflöde
+
+SMHI API → Väderdata → Riskanalys → Varningar → API
+
+## Spårbarhet
+
+- All data har source="smhi_real"
+- Tidsstämplar på alla observationer
+- Väderstation dokumenterad
+
+## Körning
+
+```bash
+# Hämta väderdata
+python3 ingestion/smhi_weather.py
+
+# Generera varningar
+python3 processing/weather_analysis.py
+
+# Hämta via API
+python3 api/weather_alerts.py
+
+# Kör tester
+python3 tests/test_weather_analysis.py
+```

life-prod/ingestion/fetch_osm_roads.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+import requests
+import sqlite3
+from datetime import datetime
+
+DB_PATH = "/home/bernt/.openclaw/workspace/rivp-pilot-1/rivp.db"
+
+def fetch_roads():
+    query = '[out:json];way["highway"~"motorway|trunk|primary|secondary"](59.8,17.4,60.1,17.8);out body;'
+    
+    response = requests.post(
+        "https://overpass-api.de/api/interpreter",
+        data={"data": query},
+        timeout=60
+    )
+    
+    if response.status_code == 200:
+        data = response.json()
+        roads = []
+        for element in data.get("elements", []):
+            if element.get("type") == "way":
+                tags = element.get("tags", {})
+                roads.append({
+                    "osm_id": element.get("id"),
+                    "name": tags.get("name", "Unknown"),
+                    "ref": tags.get("ref", ""),
+                    "highway": tags.get("highway", ""),
+                    "surface": tags.get("surface", "")
+                })
+        return roads
+    return []
+
+def save_to_db(roads):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS osm_roads (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            osm_id INTEGER UNIQUE,
+            name TEXT,
+            ref TEXT,
+            highway_type TEXT,
+            surface TEXT,
+            imported_date TEXT,
+            source TEXT
+        )
+    ''')
+    
+    count = 0
+    for road in roads:
+        try:
+            c.execute('''
+                INSERT OR IGNORE INTO osm_roads 
+                (osm_id, name, ref, highway_type, surface, imported_date, source)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                road["osm_id"],
+                road["name"],
+                road["ref"],
+                road["highway"],
+                road["surface"],
+                datetime.now().isoformat(),
+                "openstreetmap"
+            ))
+            if c.rowcount > 0:
+                count += 1
+        except:
+            pass
+    
+    conn.commit()
+    conn.close()
+    return count
+
+if __name__ == "__main__":
+    roads = fetch_roads()
+    print(f"Hittade {len(roads)} vägar")
+    
+    for road in roads[:5]:
+        print(f"  {road['ref'] or 'N/A'}: {road['name']} ({road['highway']})")
+    
+    saved = save_to_db(roads)
+    print(f"Sparade {saved} nya vägar")

life-prod/ingestion/smhi_weather.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Hämta väderdata från SMHI
+"""
+import requests
+import sqlite3
+from datetime import datetime
+
+DB_PATH = "/home/bernt/.openclaw/workspace/rivp-pilot-1/rivp.db"
+
+def fetch_temperature(station_id="97530"):
+    """Hämta temperatur från SMHI"""
+    url = f"https://opendata-download-metobs.smhi.se/api/version/latest/parameter/1/station/{station_id}/period/latest-hour/data.json"
+    
+    try:
+        response = requests.get(url, timeout=30)
+        if response.status_code == 200:
+            data = response.json()
+            values = data.get("value", [])
+            if values:
+                latest = values[-1]
+                return {
+                    "station": data["station"]["name"],
+                    "temperature": float(latest["value"]),
+                    "timestamp": latest["date"]
+                }
+    except Exception as e:
+        print(f"Fel: {e}")
+    
+    return None
+
+def fetch_precipitation(station_id="97530"):
+    """Hämta nederbörd från SMHI"""
+    url = f"https://opendata-download-metobs.smhi.se/api/version/latest/parameter/7/station/{station_id}/period/latest-day/data.json"
+    
+    try:
+        response = requests.get(url, timeout=30)
+        if response.status_code == 200:
+            data = response.json()
+            values = data.get("value", [])
+            if values:
+                total = sum(float(v["value"]) for v in values if float(v["value"]) >= 0)
+                return {
+                    "station": data["station"]["name"],
+                    "precipitation_mm": total
+                }
+    except Exception as e:
+        print(f"Fel: {e}")
+    
+    return None
+
+def save_weather_observation(road_id, weather_type, value, severity, source="smhi_real"):
+    """Spara väderobservation"""
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    
+    c.execute('''
+        INSERT INTO observations 
+        (road_id, observation_type, latitude, longitude, confidence, severity, detected_date, source)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (
+        road_id,
+        weather_type,
+        59.85,  # Uppsala lat
+        17.65,  # Uppsala lon
+        0.95,
+        severity,
+        datetime.now().strftime('%Y-%m-%d'),
+        source
+    ))
+    
+    conn.commit()
+    conn.close()
+
+if __name__ == "__main__":
+    temp = fetch_temperature()
+    precip = fetch_precipitation()
+    
+    if temp:
+        print(f"Temperatur: {temp['temperature']}°C")
+    if precip:
+        print(f"Nederbörd: {precip['precipitation_mm']}mm")

life-prod/processing/weather_analysis.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+Analysera väderkonsekvenser för vägar
+"""
+import sqlite3
+from datetime import datetime
+
+DB_PATH = "/home/bernt/.openclaw/workspace/rivp-pilot-1/rivp.db"
+
+def analyze_weather_impact(temperature, precipitation):
+    """
+    Analysera väderpåverkan på vägar
+    Returnerar risknivå och rekommendationer
+    """
+    risks = []
+    
+    # Temperaturanalys
+    if temperature < 0:
+        risks.append({
+            "type": "ice_risk",
+            "severity": "high",
+            "description": "Risk för halka och isbildning"
+        })
+    elif temperature < 5:
+        risks.append({
+            "type": "frost_risk",
+            "severity": "medium",
+            "description": "Risk för frostskador på vägbanan"
+        })
+    
+    # Nederbördsanalys
+    if precipitation > 10:
+        risks.append({
+            "type": "flooding_risk",
+            "severity": "high",
+            "description": "Risk för översvämning och nedsatt framkomlighet"
+        })
+    elif precipitation > 5:
+        risks.append({
+            "type": "wet_road",
+            "severity": "medium",
+            "description": "Blöt vägbana, ökad bromssträcka"
+        })
+    
+    # Kombinerade effekter
+    if temperature < 0 and precipitation > 0:
+        risks.append({
+            "type": "black_ice",
+            "severity": "critical",
+            "description": "Mycket hög risk för svartis"
+        })
+    
+    return risks
+
+def get_affected_roads(county="Uppsala"):
+    """Hämta vägar i ett specifikt län"""
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    
+    c.execute("SELECT id, road_number, name, type FROM roads WHERE county = ?", (county,))
+    roads = c.fetchall()
+    
+    conn.close()
+    return roads
+
+def generate_weather_alerts():
+    """Generera vädervarningar för vägar"""
+    # Hämta senaste väderdata
+    import sys
+    sys.path.insert(0, '/home/bernt/.openclaw/workspace/life-prod/ingestion')
+    from smhi_weather import fetch_temperature, fetch_precipitation
+    
+    temp_data = fetch_temperature()
+    precip_data = fetch_precipitation()
+    
+    if not temp_data or not precip_data:
+        print("Ingen väderdata tillgänglig")
+        return []
+    
+    temperature = temp_data["temperature"]
+    precipitation = precip_data["precipitation_mm"]
+    
+    # Analysera risker
+    risks = analyze_weather_impact(temperature, precipitation)
+    
+    # Hämta påverkade vägar
+    roads = get_affected_roads()
+    
+    alerts = []
+    for road in roads:
+        for risk in risks:
+            alerts.append({
+                "road_id": road[0],
+                "road_number": road[1],
+                "road_name": road[2],
+                "road_type": road[3],
+                "risk_type": risk["type"],
+                "severity": risk["severity"],
+                "description": risk["description"],
+                "temperature": temperature,
+                "precipitation": precipitation,
+                "timestamp": datetime.now().isoformat()
+            })
+    
+    return alerts
+
+if __name__ == "__main__":
+    alerts = generate_weather_alerts()
+    print(f"Genererade {len(alerts)} vädervarningar")
+    
+    # Visa första 3
+    for alert in alerts[:3]:
+        print(f"  {alert['road_number']}: {alert['risk_type']} ({alert['severity']})")

life-prod/tests/test_weather_analysis.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+Tester för väderanalys
+"""
+import sys
+sys.path.insert(0, '/home/bernt/.openclaw/workspace/life-prod/processing')
+from weather_analysis import analyze_weather_impact
+
+def test_ice_risk():
+    """Testa isrisk vid minusgrader"""
+    risks = analyze_weather_impact(-5, 0)
+    assert len(risks) > 0
+    assert any(r["type"] == "ice_risk" for r in risks)
+    print("✓ test_ice_risk passed")
+
+def test_flooding_risk():
+    """Testa översvämningsrisk vid kraftigt regn"""
+    risks = analyze_weather_impact(10, 15)
+    assert any(r["type"] == "flooding_risk" for r in risks)
+    print("✓ test_flooding_risk passed")
+
+def test_black_ice():
+    """Testa svartis vid kallt + nederbörd"""
+    risks = analyze_weather_impact(-2, 5)
+    assert any(r["type"] == "black_ice" for r in risks)
+    assert any(r["severity"] == "critical" for r in risks)
+    print("✓ test_black_ice passed")
+
+def test_no_risk():
+    """Testa att ingen risk vid bra väder"""
+    risks = analyze_weather_impact(22, 0)
+    assert len(risks) == 0
+    print("✓ test_no_risk passed")
+
+if __name__ == "__main__":
+    test_ice_risk()
+    test_flooding_risk()
+    test_black_ice()
+    test_no_risk()
+    print("\nAlla tester klara!")