Upload app.py

app.py

@@ -0,0 +1,337 @@
+"""
+Taxi Fastprisräknare – OSM/ORS version (100% gratis)
+
+Funktioner:
+- Geokodar fria områden/adresser via OpenStreetMap Nominatim
+- Hämtar avstånd/tid via OpenRouteService (om API-nyckel finns) annars OSRM (gratis, ingen nyckel)
+- Låsta km-priser härledda från jämförpris (10 km / 15 min)
+- Offline-schablon om API:er inte svarar
+
+Körning:
+  pip install streamlit requests streamlit-geolocation
+  streamlit run app.py
+
+Valfri konfig (för högre stabilitet och kvoter):
+  Skapa .streamlit/secrets.toml och lägg in:
+    OPENROUTESERVICE_API_KEY = "din_ors_key"
+
+Obs: Följ Nominatims användarpolicy; vi sätter en User-Agent och pausar vid 429/503.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict, Optional, Tuple
+import time
+import json
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import streamlit as st
+import requests
+
+# Försök hämta geolokalisering från webbläsaren (valfritt)
+try:
+    from streamlit_geolocation import st_geolocation  # type: ignore
+except Exception:  # pragma: no cover
+    def st_geolocation():  # fallback-dummy
+        st.info("Geolocation-modulen saknas eller blockeras – använder manuell adress.")
+        return None
+
+# ------------------ Tariffer ------------------ #
+@dataclass(frozen=True)
+class Tariff:
+    name: str
+    base_fee: float          # Grundavgift i SEK
+    eff_km_price: float      # Låst effektiv km-kostnad (från jämförpris)
+    time_per_hour: float     # SEK/h
+    internal_key: int        # metadata
+    compare_price: float     # jämförpris 10 km / 15 min (metadata)
+
+TARIFFS: Dict[str, Tariff] = {
+    "Personbil (avtalskund)": Tariff(
+        "Personbil (avtalskund)",
+        base_fee=60.0,
+        eff_km_price=16.0,
+        time_per_hour=717.0,   # 11.95 kr/min
+        internal_key=717,
+        compare_price=399.0,
+    ),
+    "Personbil (alla dagar)": Tariff(
+        "Personbil (alla dagar)",
+        base_fee=60.0,
+        eff_km_price=17.0,
+        time_per_hour=730.0,   # 12.20 kr/min
+        internal_key=730,
+        compare_price=413.0,
+    ),
+    "Storbilstaxa (alla tider)": Tariff(
+        "Storbilstaxa (alla tider)",
+        base_fee=87.0,
+        eff_km_price=28.0,
+        time_per_hour=929.0,   # 15.50 kr/min
+        internal_key=929,
+        compare_price=599.0,
+    ),
+}
+
+# ------------------ Hjälpare ------------------ #
+NOMINATIM_URL = "https://nominatim.openstreetmap.org/search"
+OSRM_URL = "https://router.project-osrm.org/route/v1/driving/{lon1},{lat1};{lon2},{lat2}?overview=false&alternatives=false&steps=false"
+ORS_URL = "https://api.openrouteservice.org/v2/directions/driving-car"
+
+SESSION = requests.Session()
+SESSION.headers.update({
+    "User-Agent": "TaxiFastpris/1.0 (kontakt: example@example.com)",
+    "Accept-Language": "sv-SE,sv;q=0.9",
+})
+
+
+def backoff_sleep(retry: int) -> None:
+    time.sleep(min(2 ** retry, 8))
+
+
+
+# --- IP-baserad fallback för geolokalisering ---
+@st.cache_data(ttl=600)
+def ip_geolocate() -> Optional[Tuple[float, float, str]]:
+    """Approximate location via IP (no key). Returns (lat, lon, label)."""
+    try:
+        r = SESSION.get("https://ipapi.co/json/", timeout=5)
+        r.raise_for_status()
+        d = r.json()
+        lat = d.get("latitude"); lon = d.get("longitude")
+        if lat is None or lon is None:
+            return None
+        lat = float(lat); lon = float(lon)
+        city = d.get("city") or "IP-position"
+        return (lat, lon, f"{city} (IP-position)")
+    except Exception:
+        return None
+
+
+@st.cache_data(ttl=3600, show_spinner=False)
+def geocode_nominatim(query: str) -> Optional[Tuple[float, float, str]]:
+    """Geokoda fri text via Nominatim. Begränsad till Stockholms län. Returnerar (lat, lon, label)."""
+    params = {
+        "q": query,
+        "format": "json",
+        "addressdetails": 0,
+        "namedetails": 0,
+        "limit": 1,
+        "countrycodes": "se",
+        "viewbox": "16.9,60.6,19.9,58.5",  # left,top,right,bottom (lon,lat)
+        "bounded": 1,
+        "accept-language": "sv-SE,sv;q=0.9",
+    }
+    for attempt in range(2):
+        try:
+            r = SESSION.get(NOMINATIM_URL, params=params, timeout=5)
+            if r.status_code in (429, 503):
+                backoff_sleep(attempt)
+                continue
+            r.raise_for_status()
+            data = r.json()
+            if not data:
+                return None
+            item = data[0]
+            lat = float(item["lat"]); lon = float(item["lon"])
+            label = item.get("display_name") or query
+            return (lat, lon, label)
+        except Exception:
+            backoff_sleep(attempt)
+    return None
+@st.cache_data(ttl=900, show_spinner=False)
+def route_fast(start: Tuple[float, float], dest: Tuple[float, float]) -> Optional[Tuple[float, float]]:
+    """Run ORS and OSRM in parallel and return the first successful (km, min)."""
+    def try_ors():
+        return route_openrouteservice(start, dest)
+    def try_osrm():
+        return route_osrm(start, dest)
+
+    with ThreadPoolExecutor(max_workers=2) as ex:
+        futures = [ex.submit(fn) for fn in (try_ors, try_osrm)]
+        for f in as_completed(futures):
+            try:
+                res = f.result()
+                if res:
+                    return res
+            except Exception:
+                continue
+    return None
+
+
+@st.cache_data(ttl=3600)
+def route_openrouteservice(start: Tuple[float, float], dest: Tuple[float, float]) -> Optional[Tuple[float, float]]:
+    """Anropa ORS om nyckel finns. Returnerar (km, min)."""
+    api_key = st.secrets.get("OPENROUTESERVICE_API_KEY")
+    if not api_key:
+        return None
+    headers = {"Authorization": api_key, "Content-Type": "application/json"}
+    body = {"coordinates": [[start[1], start[0]], [dest[1], dest[0]]]}  # lon,lat
+    for attempt in range(2):
+        try:
+            r = SESSION.post(ORS_URL, headers=headers, data=json.dumps(body), timeout=10)
+            if r.status_code == 429:
+                backoff_sleep(attempt)
+                continue
+            r.raise_for_status()
+            data = r.json()
+            summary = data["features"][0]["properties"]["summary"]
+            dist_km = float(summary["distance"]) / 1000.0
+            dur_min = float(summary["duration"]) / 60.0
+            return (dist_km, dur_min)
+        except Exception:
+            backoff_sleep(attempt)
+    return None
+
+
+@st.cache_data(ttl=3600)
+def route_osrm(start: Tuple[float, float], dest: Tuple[float, float]) -> Optional[Tuple[float, float]]:
+    """Gratis fallback via OSRM publika servern. Returnerar (km, min)."""
+    url = OSRM_URL.format(lon1=start[1], lat1=start[0], lon2=dest[1], lat2=dest[0])
+    for attempt in range(2):
+        try:
+            r = SESSION.get(url, timeout=10)
+            if r.status_code in (429, 503):
+                backoff_sleep(attempt)
+                continue
+            r.raise_for_status()
+            data = r.json()
+            route = data.get("routes", [{}])[0]
+            if not route:
+                return None
+            dist_km = float(route.get("distance", 0.0)) / 1000.0
+            dur_min = float(route.get("duration", 0.0)) / 60.0
+            return (dist_km, dur_min)
+        except Exception:
+            backoff_sleep(attempt)
+    return None
+
+
+def compute_price(t: Tariff, km: float, minutes: float) -> Dict[str, float]:
+    time_per_min = t.time_per_hour / 60.0
+    km_cost = t.eff_km_price * km
+    time_cost = time_per_min * minutes
+    total = t.base_fee + km_cost + time_cost
+    return {
+        "base": t.base_fee,
+        "km_cost": km_cost,
+        "time_cost": time_cost,
+        "total": total,
+        "total_rounded": float(int(round(total))),
+    }
+
+# ------------------ UI ------------------ #
+st.set_page_config(page_title="Taxi Fastprisräknare (OSM)", page_icon="🚖", layout="centered")
+st.title("🚖 Taxi Fastprisräknare")
+st.caption("OSM/ORS – gratis. Jämförpris definierar låsta km-satser. Inmatning kan vara områden, t.ex. Skärholmen → Farsta.")
+
+use_geo = st.toggle("Använd min position", value=False)
+col1, col2 = st.columns(2)
+
+start_latlng: Optional[Tuple[float, float]] = None
+start_label = ""
+
+if use_geo:
+    pos = st_geolocation()
+    if pos and pos.get("latitude") and pos.get("longitude"):
+        start_latlng = (float(pos["latitude"]), float(pos["longitude"]))
+        start_label = f"({start_latlng[0]:.5f}, {start_latlng[1]:.5f})"
+    else:
+        ip_pos = ip_geolocate()
+        if ip_pos:
+            start_latlng = (ip_pos[0], ip_pos[1])
+            start_label = ip_pos[2]
+            st.info("Kunde inte läsa GPS – använder IP-baserad position som start.")
+        else:
+            st.info("Kunde inte läsa position – ange start manuellt.")
+
+with col1:
+    start_text = st.text_input("Start (adress/område)", value="")
+with col2:
+    dest_text = st.text_input("Destination (adress/område)", value="")
+
+choice = st.selectbox("Fordonstyp/Tariff", list(TARIFFS.keys()), index=2)
+tariff = TARIFFS[choice]
+
+show_breakdown = st.checkbox("Visa detaljerad kostnadsuppdelning", value=True)
+use_offline = st.checkbox("Använd offline-schablon om API faller", value=False)
+
+if use_offline:
+    with st.expander("Offline-inställningar", expanded=True):
+        OFFLINE_KM = st.number_input("Offline: schablonavstånd (km)", 1.0, 50.0, 8.0, step=0.5)
+        OFFLINE_MIN = st.number_input("Offline: schablontid (min)", 1.0, 120.0, 15.0, step=1.0)
+else:
+    OFFLINE_KM, OFFLINE_MIN = 8.0, 15.0
+
+if st.button("Beräkna pris", type="primary"):
+    origin: Optional[Tuple[float, float]] = None
+    dest: Optional[Tuple[float, float]] = None
+    origin_label = start_label
+    dest_label = ""
+
+    # Geokodning
+    with st.spinner("Söker adresser i Stockholms län..."):
+        if start_latlng:
+            origin = start_latlng
+        elif start_text.strip():
+            geo_o = geocode_nominatim(start_text.strip())
+            if geo_o:
+                origin = (geo_o[0], geo_o[1])
+                origin_label = geo_o[2]
+
+        if dest_text.strip():
+            geo_d = geocode_nominatim(dest_text.strip())
+            if geo_d:
+                dest = (geo_d[0], geo_d[1])
+                dest_label = geo_d[2]
+
+    # Rutt (km/min)
+    dist_km: float
+    dur_min: float
+    route_ok = False
+    if origin and dest:
+        with st.spinner("Beräknar rutt och tid..."):
+            rt = route_fast(origin, dest)
+            if rt:
+                dist_km, dur_min = rt
+                route_ok = True
+
+    if not route_ok:
+        if use_offline:
+            dist_km, dur_min = OFFLINE_KM, OFFLINE_MIN
+        else:
+            st.error("Kunde inte hämta sträcka/tid – slå på offline-schablon eller kontrollera adresser.")
+            st.stop()
+
+    # Prisberäkning
+    res = compute_price(tariff, km=dist_km, minutes=dur_min)
+
+    st.subheader("Resultat")
+    highlighted = (
+        f"Total: {int(res['total_rounded'])} kr (distans {dist_km:.1f} km, tid {dur_min:.0f} min, tariff: {tariff.name})"
+    )
+    st.markdown(
+        f"""
+        <div style="padding:16px;border-radius:10px;border:1px solid #f0c36d;background:#fff8db;font-weight:700;font-size:20px;">
+            {highlighted}
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    if show_breakdown:
+        st.markdown("**Kostnadsuppdelning**")
+        st.table({
+            "Post": ["Grundavgift", "Km-kostnad", "Tidskostnad", "Summa (avrundad)"],
+            "SEK": [f"{tariff.base_fee:.0f}", f"{res['km_cost']:.0f}", f"{res['time_cost']:.0f}", f"{res['total_rounded']:.0f}"]
+        })
+
+    price_line = (
+        f"Fastpris {int(res['total_rounded'])} kr – {dist_km:.1f} km / {dur_min:.0f} min – {tariff.name} – "
+        f"{datetime.now().strftime('%Y-%m-%d %H:%M')}"
+    )
+    st.text_input("Kopiera prisrad", value=price_line, help="Markera och kopiera.")
+
+st.markdown("---")
+st.caption("OSM/ORS-version · Låsta km-priser · Inga Google-API:er · Byggd för Sam")