287 lines
13 KiB
Plaintext
287 lines
13 KiB
Plaintext
"""Dona V8.3: keyless, user-triggered navigation + optional HA phone hand-off.
|
||
|
||
Geocoding with Nominatim (low volume; cache + <=1 request/s); OSRM demo for
|
||
personal experimentation, switch to a private OSRM for reliable routes.
|
||
No geolocation is inferred. No credentials are stored in this module.
|
||
"""
|
||
from __future__ import annotations
|
||
import json
|
||
import math
|
||
import os
|
||
from pathlib import Path
|
||
import re
|
||
import threading
|
||
import time
|
||
from urllib.parse import urlencode, urlsplit
|
||
|
||
import requests
|
||
from flask import Blueprint, jsonify, request
|
||
|
||
MAX_DEST=180
|
||
_AGENT='DonaNavigation/8.3 (private household assistant; contact: '+os.getenv('DONA_NAV_CONTACT','local-admin')+')'
|
||
_NOMINATIM='https://nominatim.openstreetmap.org'
|
||
_OSRM_DEMO='https://router.project-osrm.org'
|
||
_LOCK=threading.RLock()
|
||
_NEXT_REQUEST={'geo':0.0,'route':0.0}
|
||
_CACHE={}
|
||
_CACHE_READY=False
|
||
_CACHE_LIMIT=400
|
||
_CACHE_TTL=30*86400
|
||
|
||
class NavigationError(RuntimeError):
|
||
pass
|
||
|
||
def _config_url(name, default):
|
||
val=os.getenv(name,default).strip().rstrip('/')
|
||
u=urlsplit(val)
|
||
if not (u.scheme in ('http','https') and u.hostname and not u.username and not u.password and not u.fragment and not u.query):
|
||
raise NavigationError(f'Adresse {name} invalide.')
|
||
return val
|
||
|
||
def _cache_file():
|
||
return Path(os.getenv('DONA_NAV_CACHE_FILE','/opt/alfred/app/cache/dona_navigation.json'))
|
||
|
||
def _get_cache():
|
||
global _CACHE_READY
|
||
if not _CACHE_READY:
|
||
try:
|
||
raw=json.loads(_cache_file().read_text(encoding='utf-8'))
|
||
if isinstance(raw,dict):_CACHE.update({str(k):v for k,v in raw.items() if isinstance(v,dict)})
|
||
except (OSError,ValueError): pass
|
||
_CACHE_READY=True
|
||
return _CACHE
|
||
|
||
def _save_cache():
|
||
try:
|
||
path=_cache_file();path.parent.mkdir(parents=True,exist_ok=True)
|
||
entries=sorted(_CACHE.items(),key=lambda x:x[1].get('at',0),reverse=True)[:_CACHE_LIMIT]
|
||
tmp=path.with_name(path.name+'.tmp')
|
||
tmp.write_text(json.dumps(dict(entries),ensure_ascii=False,separators=(',',':')),encoding='utf-8')
|
||
tmp.replace(path)
|
||
except OSError:
|
||
pass # caching is optional; never block navigation
|
||
|
||
def _cached(key):
|
||
with _LOCK:
|
||
rec=_get_cache().get(key)
|
||
if rec and time.time()-float(rec.get('at',0))<_CACHE_TTL:
|
||
return rec.get('data')
|
||
return None
|
||
|
||
def _remember(key,data):
|
||
with _LOCK:
|
||
_get_cache()[key]={'at':time.time(),'data':data}
|
||
_save_cache()
|
||
|
||
def _request(kind, base, suffix, params):
|
||
# All endpoint hosts are configured by the server administrator, never by callers.
|
||
with _LOCK:
|
||
wait=max(0.0,_NEXT_REQUEST[kind]-time.monotonic())
|
||
if wait:time.sleep(wait)
|
||
_NEXT_REQUEST[kind]=time.monotonic()+1.1
|
||
try:
|
||
resp=requests.get(base+suffix,params=params,timeout=(4,11),headers={
|
||
'User-Agent':_AGENT, 'Accept':'application/json', 'Accept-Language':'fr'})
|
||
resp.raise_for_status()
|
||
if len(resp.content)>1_500_000:raise NavigationError('Réponse cartographique trop volumineuse.')
|
||
return resp.json()
|
||
except (requests.RequestException,ValueError) as exc:
|
||
raise NavigationError('Service cartographique momentanément indisponible.') from exc
|
||
|
||
def _place(value):
|
||
if not isinstance(value,str) or not 2<=len(value.strip())<=MAX_DEST:
|
||
raise NavigationError('Indique une destination de 2 à 180 caractères.')
|
||
text=' '.join(value.strip().split())
|
||
if re.search(r'[\x00-\x1f]',text):raise NavigationError('Destination invalide.')
|
||
return text
|
||
|
||
def _coord(lat,lon):
|
||
try: a,b=float(lat),float(lon)
|
||
except (ValueError,TypeError):raise NavigationError('Coordonnées invalides.') from None
|
||
if not math.isfinite(a) or not math.isfinite(b) or not (-90<=a<=90 and -180<=b<=180):
|
||
raise NavigationError('Coordonnées hors limites.')
|
||
return round(a,6),round(b,6)
|
||
|
||
def search_location(query):
|
||
query=_place(query)
|
||
key='geo:'+query.casefold()
|
||
hit=_cached(key)
|
||
if hit is not None:return hit
|
||
base=_config_url('DONA_NAV_GEOCODER_URL',_NOMINATIM)
|
||
raw=_request('geo',base,'/search',{'q':query,'format':'jsonv2','limit':3,'accept-language':'fr'})
|
||
results=[]
|
||
for entry in raw if isinstance(raw,list) else []:
|
||
if not isinstance(entry,dict):continue
|
||
try:lat,lon=_coord(entry.get('lat'),entry.get('lon'))
|
||
except NavigationError:continue
|
||
results.append({'name':str(entry.get('display_name') or query)[:220], 'lat':lat,'lon':lon})
|
||
_remember(key,results)
|
||
return results
|
||
|
||
def _origin_text(origin=None):
|
||
# No guessed location, ever. Caller or administrator must provide one.
|
||
val=(origin or os.getenv('DONA_NAV_ORIGIN','')).strip()
|
||
return _place(val) if val else None
|
||
|
||
def external_links(dest,dest_point=None):
|
||
query=_place(dest)
|
||
if dest_point:
|
||
lat,lon=_coord(dest_point['lat'],dest_point['lon'])
|
||
waze='https://www.waze.com/ul?'+urlencode({'ll':f'{lat},{lon}','navigate':'yes','utm_source':'DonaNavigation'})
|
||
maps='https://www.google.com/maps/dir/?'+urlencode({'api':'1','destination':f'{lat},{lon}','travelmode':'driving'})
|
||
else:
|
||
waze='https://www.waze.com/ul?'+urlencode({'q':query,'navigate':'yes','utm_source':'DonaNavigation'})
|
||
maps='https://www.google.com/maps/dir/?'+urlencode({'api':'1','destination':query,'travelmode':'driving'})
|
||
return {'waze':waze,'google_maps':maps}
|
||
|
||
def _route_between(start,end):
|
||
key=f"route:{start['lat']},{start['lon']}:{end['lat']},{end['lon']}"
|
||
hit=_cached(key)
|
||
if hit is not None:return hit
|
||
base=_config_url('DONA_NAV_ROUTER_URL',_OSRM_DEMO)
|
||
coords=f"{start['lon']},{start['lat']};{end['lon']},{end['lat']}"
|
||
raw=_request('route',base,'/route/v1/driving/'+coords,{'overview':'simplified','geometries':'geojson','steps':'false'})
|
||
routes=raw.get('routes',[]) if isinstance(raw,dict) and raw.get('code')=='Ok' else []
|
||
if not routes:raise NavigationError('Aucun itinéraire routier calculable.')
|
||
r=routes[0]
|
||
coords=(r.get('geometry') or {}).get('coordinates') or []
|
||
line=[]
|
||
for p in coords[:700]:
|
||
if not isinstance(p,list) or len(p)<2:continue
|
||
lat,lon=_coord(p[1],p[0]);line.append([lat,lon])
|
||
# Need a meaningful route before returning a claimed ETA.
|
||
if len(line)<2:raise NavigationError('Géométrie d’itinéraire indisponible.')
|
||
meters=float(r['distance']);seconds=float(r['duration'])
|
||
if any(not math.isfinite(x) or x<0 for x in (meters,seconds)):
|
||
raise NavigationError('Durée de trajet invalide.')
|
||
out={'distance_km':round(meters/1000,1),'duration_min':round(seconds/60),'line':line,
|
||
'traffic_included':False,'provider':'OSRM'}
|
||
_remember(key,out)
|
||
return out
|
||
|
||
def build(destination,origin=None):
|
||
dest=_place(destination)
|
||
result={'destination':dest,'origin':None,'place':None,'route':None,'note':'', 'links':external_links(dest),
|
||
'attribution':'© OpenStreetMap contributors'}
|
||
try:
|
||
hits=search_location(dest)
|
||
if hits:
|
||
result['place']=hits[0];result['links']=external_links(dest,hits[0])
|
||
else:result['note']='Adresse non trouvée ; ouvre Waze pour vérifier la destination.'
|
||
except NavigationError as exc:result['note']=str(exc)+' Le lien Waze reste disponible.'
|
||
try: start=_origin_text(origin)
|
||
except NavigationError as exc:result['note']=str(exc);start=None
|
||
if start and result['place']:
|
||
result['origin']=start
|
||
try:
|
||
matches=search_location(start)
|
||
if matches:result['route']=_route_between(matches[0],result['place']);result['origin_place']=matches[0]
|
||
else:result['note']='Point de départ introuvable : trajet non calculé.'
|
||
except NavigationError as exc:result['note']=str(exc)+' Tu peux ouvrir Waze pour calculer l’itinéraire.'
|
||
elif not start and not result['note']:
|
||
result['note']='Renseigne un point de départ pour calculer la durée. Sans départ, seule la destination est affichée.'
|
||
return result
|
||
|
||
# Explicit speech routing. Does not intercept ordinary conversation or media controls.
|
||
_NAV_RE=re.compile(r'\b(?:waze|gps|google maps|itin[eé]raire|trajet|navigation|destination|route vers|temps pour (?:aller|me rendre)|aller [aà] )\b',re.I)
|
||
_SEND_RE=re.compile(r'\b(?:envoie|envoies|transf[eè]re|partage|sur mon t[eé]l[eé]phone|à mon t[eé]l[eé]phone)\b',re.I)
|
||
|
||
def is_request(text):
|
||
return isinstance(text,str) and 3<=len(text)<500 and bool(_NAV_RE.search(text))
|
||
|
||
def is_send(text):return bool(_SEND_RE.search(text or ''))
|
||
|
||
def extract_destination(text):
|
||
s=str(text or '').strip()
|
||
s=re.sub(r'^(?:dona|alfred)[,\s]+','',s,flags=re.I)
|
||
patterns=[r'^.*?\b(?:itin[eé]raire|trajet|destination|route)\s+(?:pour|vers|jusqu[\'’]?[aà]|[aà])\s+',
|
||
r'^.*?\b(?:aller|rendre)\s+(?:[aà]|au|aux|en)\s+',
|
||
r'^.*?\b(?:waze|google maps|gps)\s+(?:pour|vers|jusqu[\'’]?[aà]|[aà])\s+',
|
||
r'^.*?\b(?:jusqu[\'’]?[aà])\s+']
|
||
for pat in patterns:
|
||
found=re.search(pat,s,re.I)
|
||
if found:s=s[found.end():];break
|
||
s=re.sub(r'\s+(?:sur|dans)\s+(?:waze|google maps)\s*$','',s,flags=re.I)
|
||
s=s.rstrip(' .?!;,')
|
||
return s[:MAX_DEST] if 2<=len(s)<=MAX_DEST else None
|
||
|
||
# DONA_NAV_FIX_V831: same validation for config display and real HA sends.
|
||
def _notify_service_name():
|
||
service=os.getenv('DONA_NAV_HA_NOTIFY_SERVICE','').strip()
|
||
match=re.fullmatch(r'notify\.([a-z0-9_]+)',service)
|
||
return match.group(1) if match else None
|
||
|
||
def _notify_url(destination,url):
|
||
service_name=_notify_service_name()
|
||
if not service_name:raise NavigationError('Configure un service Home Assistant valide dans DONA_NAV_HA_NOTIFY_SERVICE (notify.*).')
|
||
base=(os.getenv('HA_URL') or os.getenv('HOME_ASSISTANT_URL') or '').strip().rstrip('/')
|
||
token=(os.getenv('HA_TOKEN') or os.getenv('HOME_ASSISTANT_TOKEN') or '').strip()
|
||
if not base or not token:raise NavigationError('Home Assistant : HA_URL ou HA_TOKEN manquant.')
|
||
u=urlsplit(base)
|
||
if u.scheme not in ('http','https') or not u.hostname or u.username or u.password:
|
||
raise NavigationError('Adresse Home Assistant invalide.')
|
||
payload={'title':'Itinéraire Dona','message':'Ouvrir Waze pour '+destination,
|
||
'data':{'url':url,'clickAction':url}}
|
||
try:
|
||
res=requests.post(base+'/api/services/notify/'+service_name,json=payload,
|
||
headers={'Authorization':'Bearer '+token,'Content-Type':'application/json'},timeout=10)
|
||
res.raise_for_status()
|
||
except requests.RequestException as exc:
|
||
raise NavigationError('Notification Home Assistant refusée ou inaccessible.') from exc
|
||
return True
|
||
|
||
def send_to_phone(destination):
|
||
dest=_place(destination)
|
||
# Only links generated on server; never a caller-provided URL.
|
||
return _notify_url(dest,external_links(dest)['waze'])
|
||
|
||
def _allowed_request():
|
||
if not request.is_json or request.headers.get('X-Alfred-Request')!='1':return False
|
||
origin=request.headers.get('Origin')
|
||
if origin:
|
||
try:
|
||
u=urlsplit(origin)
|
||
return u.scheme in ('http','https') and u.netloc==request.host
|
||
except ValueError:return False
|
||
return request.headers.get('Sec-Fetch-Site','same-origin') in ('same-origin','none')
|
||
|
||
def register_navigation(app,socketio):
|
||
bp=Blueprint('dona_navigation_v83',__name__)
|
||
@bp.post('/api/dona/navigation/search')
|
||
def query():
|
||
if not _allowed_request():return jsonify(ok=False,error='Requête refusée.'),403
|
||
data=request.get_json(silent=True) or {}
|
||
try:return jsonify(ok=True,**build(data.get('destination'),data.get('origin')))
|
||
except NavigationError as exc:return jsonify(ok=False,error=str(exc)),400
|
||
@bp.post('/api/dona/navigation/send')
|
||
def notify():
|
||
if not _allowed_request():return jsonify(ok=False,error='Requête refusée.'),403
|
||
try:
|
||
dest=_place((request.get_json(silent=True) or {}).get('destination'))
|
||
send_to_phone(dest)
|
||
return jsonify(ok=True,message='Notification Waze envoyée au téléphone configuré.')
|
||
except NavigationError as exc:return jsonify(ok=False,error=str(exc)),400
|
||
@bp.get('/api/dona/navigation/config')
|
||
def settings():
|
||
return jsonify(ok=True,origin=os.getenv('DONA_NAV_ORIGIN',''),
|
||
phone_configured=bool(_notify_service_name()))
|
||
app.register_blueprint(bp)
|
||
|
||
def handle_and_emit(text,socketio,state,state_lock):
|
||
dest=extract_destination(text)
|
||
if not dest:
|
||
msg='Indique une destination, par exemple : montre-moi le trajet vers Metz.'
|
||
result={'type':'dona_navigation','error':msg}
|
||
else:
|
||
result={'type':'dona_navigation', **build(dest)}
|
||
msg='Voici la destination '+dest+'.'
|
||
if result.get('route'):
|
||
msg+=f" Distance : {result['route']['distance_km']} kilomètres ; durée indicative : {result['route']['duration_min']} minutes, hors trafic."
|
||
if is_send(text):
|
||
try:send_to_phone(dest);result['sent']=True;msg+=' Le lien Waze a été envoyé au téléphone configuré.'
|
||
except NavigationError as exc:result['send_error']=str(exc);msg+=' Je n’ai pas pu envoyer la notification : '+str(exc)
|
||
with state_lock:
|
||
state['content']=result
|
||
socketio.emit('alfred_render',result)
|
||
return msg
|