File size: 3,410 Bytes
124816b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
"""Local operator APIs. External ingestion uses the existing device-key boundary."""
import os
import secrets
from typing import Literal, Optional
from fastapi import APIRouter, Header, HTTPException
from pydantic import BaseModel, Field
from . import pipeline, intelligence, observations, store, locations

router=APIRouter(prefix='/api')
Wadi=str
Mode=Literal['real','demo']

@router.get('/areas/search')
def place_search(q:str=''):
    return locations.search(q)

@router.post('/areas')
def save_area(req:locations.AreaRequest):
    return locations.save(req)

def device_auth(key):
    configured=os.environ.get('SATFORGE_DEVICE_KEY')
    if not configured:raise HTTPException(503,'Configure SATFORGE_DEVICE_KEY before accepting observations')
    if not secrets.compare_digest(key or '',configured):raise HTTPException(401,'Invalid device key')

@router.get('/intelligence')
def briefing(wadi:Wadi='shawka',mode:Mode='real'):
    return pipeline.briefing(wadi,mode)

class RunRequest(BaseModel):
    wadi:Wadi='shawka'
    mode:Mode='real'
    refresh_external:bool=False

@router.post('/intelligence/run')
def run(req:RunRequest):
    from .app import job
    return job('Monitoring cycle',pipeline.process,req.wadi,req.mode,req.refresh_external)

@router.get('/intelligence/settings')
def settings():return intelligence.settings().model_dump()

@router.put('/intelligence/settings')
def settings_update(req:intelligence.PipelineSettings):
    store.put('config',req.model_dump(),'pipeline');pipeline.wake()
    store.event('Research monitoring settings updated','SYSTEM')
    return req.model_dump()

@router.get('/intelligence/predictions/{id}')
def prediction(id:str):return store.get('predictions',id)

@router.get('/intelligence/assets/{id}')
def asset(id:str):return store.get('assets',id)

class ReplayRequest(BaseModel):
    wadi:Wadi='shawka'
    profile:Literal['dry','watch','storm']='storm'

@router.post('/intelligence/replay')
def replay(req:ReplayRequest):
    from .app import job
    return job('Synthetic pipeline replay',pipeline.replay,req.wadi,req.profile)

class Acknowledgement(BaseModel):
    operator:str=Field(default='Local operator',min_length=1,max_length=120)
    note:str=Field(default='',max_length=1000)

@router.post('/alerts/{id}/acknowledge')
def acknowledge(id:str,req:Acknowledgement):
    return intelligence.acknowledge(id,req.operator,req.note)

@router.get('/alerts')
def alerts(wadi:Wadi='shawka',mode:Mode='real'):
    locations.get_area(wadi)
    return [a for a in store.all_records('alerts') if a['wadi']==wadi and a['mode']==mode]

@router.post('/observations')
def ingest(req:observations.Observation,x_device_key:Optional[str]=Header(None)):
    device_auth(x_device_key)
    result=observations.ingest(req)
    if not result['duplicate']:
        store.event('Environmental observation ingested',req.category,observation_id=result['id'])
        pipeline.wake()
    return result

@router.get('/observations')
def ledger(wadi:Wadi='shawka',mode:Mode='real',limit:int=100):
    if not 1<=limit<=500:raise HTTPException(422,'Limit must be between 1 and 500')
    return [{**o,'current_quality':observations.quality(o)} for o in store.all_records('observations')
            if intelligence.in_area(o,wadi) and (o['category']=='simulation')==(mode=='demo')][:limit]