Download backend/operations.py from m4az19/saef-api: direct link, hf CLI and curl.
- Browser
- Download file 7.69 kB
-
https://huggingface.co/spaces/m4az19/saef-api/resolve/main/backend/operations.py
- Command line
-
hf download hf://spaces/m4az19/saef-api/backend/operations.py
-
curl -L -o operations.py https://huggingface.co/spaces/m4az19/saef-api/resolve/main/backend/operations.py
7.69 kB
| import math | |
| from datetime import datetime, timezone | |
| from typing import Optional,Literal | |
| from pydantic import BaseModel,Field,ConfigDict,model_validator | |
| from .store import put,get,all_records,now | |
| class Telemetry(BaseModel): | |
| model_config=ConfigDict(extra='forbid',allow_inf_nan=False) | |
| device_id:str=Field(min_length=1,max_length=64) | |
| packet_id:Optional[str]=Field(default=None,min_length=1,max_length=120) | |
| sequence:Optional[int]=Field(default=None,ge=0) | |
| measured_at:datetime | |
| solar_voltage_v:Optional[float]=Field(default=None,ge=0,le=100) | |
| solar_current_a:Optional[float]=Field(default=None,ge=0,le=20) | |
| battery_voltage_v:Optional[float]=Field(default=None,ge=0,le=100) | |
| consumption_w:Optional[float]=Field(default=None,ge=0,le=1000) | |
| battery_soc_pct:Optional[float]=Field(default=None,ge=0,le=100) | |
| soc_method:Literal['unavailable','fuel-gauge','coulomb-counting','simulated']='unavailable' | |
| temperature_c:Optional[float]=Field(default=None,ge=-80,le=100) | |
| humidity_pct:Optional[float]=Field(default=None,ge=0,le=100) | |
| pressure_hpa:Optional[float]=Field(default=None,ge=300,le=1200) | |
| illuminance_lux:Optional[float]=Field(default=None,ge=0,le=200000) | |
| provenance:Literal['MEASURED','SIMULATED']='MEASURED' | |
| def timestamps(self): | |
| from datetime import timedelta | |
| if self.measured_at.tzinfo is None:raise ValueError('Telemetry timestamp requires a timezone') | |
| if self.measured_at>datetime.now(timezone.utc)+timedelta(minutes=5):raise ValueError('Telemetry cannot be measured in the future') | |
| return self | |
| def power(t:Telemetry): | |
| d=t.model_dump(mode='json');d['received_at']=now() | |
| d['solar_power_w']=t.solar_voltage_v*t.solar_current_a if t.solar_voltage_v is not None and t.solar_current_a is not None else None | |
| if t.soc_method=='unavailable': d['battery_soc_pct']=None | |
| d['warning']='Battery SOC requires a fuel gauge or calibrated coulomb counting; voltage alone is insufficient' | |
| return d | |
| class EnergyPolicy(BaseModel): | |
| capacity_wh:float=Field(default=20,gt=0,le=10000) | |
| reserve_pct:float=Field(default=25,ge=0,le=90) | |
| ai_cost_wh:float=Field(default=.08,ge=0,le=10) | |
| transmission_cost_wh:float=Field(default=.03,ge=0,le=10) | |
| def schedule(t,policy:EnergyPolicy): | |
| soc=t.get('battery_soc_pct');energy=None if soc is None else soc/100*policy.capacity_wh | |
| available=None if energy is None else max(0,energy-policy.capacity_wh*policy.reserve_pct/100) | |
| decisions=[{'task':'essential monitoring','action':'KEEP','reason':'Highest priority; use available hardware readings'}, | |
| {'task':'storage integrity','action':'KEEP','reason':'Preserve observations while processing is deferred'}] | |
| for task,cost in [('capture',.005),('AI processing',policy.ai_cost_wh),('transmission',policy.transmission_cost_wh)]: | |
| run=available is not None and available>=cost | |
| decisions.append({'task':task,'action':'ALLOW' if run else 'DEFER','cost_wh':cost,'reason':'Within reserve budget' if run else 'Unknown energy or reserve threshold reached'}) | |
| if run: available-=cost | |
| return {'reserve_wh':energy,'decisions':decisions,'assumptions':policy.model_dump(),'warning':'Prototype scheduling; not a validated orbital energy budget'} | |
| def demo_energy(low=False): | |
| rows=[];soc=18. if low else 78.; generated=0.;used=0. | |
| for minute in range(0,121,5): | |
| voltage=5.1;current=max(0,.7*math.sin(math.pi*minute/120));load=1.4 | |
| if minute: generated+=voltage*current*5/60;used+=load*5/60;soc=max(0,min(100,(18. if low else 78.)+(generated-used)/20*100)) | |
| rows.append({'minute':minute,'solar_power_w':voltage*current,'consumption_w':load,'battery_soc_pct':soc,'generated_wh':generated,'used_wh':used}) | |
| t=power(Telemetry(device_id='demo-power',measured_at=datetime.now(timezone.utc),solar_voltage_v=voltage,solar_current_a=current, | |
| consumption_w=load,battery_soc_pct=soc,soc_method='simulated',provenance='SIMULATED')) | |
| return {'provenance':'SIMULATED','series':rows,'latest':t,'policy':schedule(t,EnergyPolicy())} | |
| class QueueItem(BaseModel): | |
| name:str=Field(max_length=120) | |
| kind:Literal['mask','risk','metadata','crop','image']='metadata' | |
| size_bytes:int=Field(gt=0,le=100_000_000) | |
| priority:int=Field(default=50,ge=0,le=100) | |
| asset_id:Optional[str]=None | |
| def enqueue(item): | |
| occupied=sum(j['size_bytes'] for j in all_records('queue') if j['state']!='sent') | |
| if occupied+item.size_bytes>100_000_000: raise ValueError('Simulated storage capacity exceeded (100 MB)') | |
| return put('queue',{**item.model_dump(),'created_at':now(),'sent_bytes':0,'state':'queued','retries':0,'provenance':'SIMULATED LINK'}) | |
| def transmit(seconds,rate_kbps,link_open,energy_allowed): | |
| budget=int(seconds*rate_kbps*1000/8) if link_open and energy_allowed else 0 | |
| moved=0 | |
| for j in sorted(all_records('queue'),key=lambda j:(-j['priority'],j['created_at'])): | |
| if j['state'] not in ('queued','transmitting'): continue | |
| amount=min(budget,j['size_bytes']-j['sent_bytes']);j['sent_bytes']+=amount;budget-=amount;moved+=amount | |
| if amount: j['state']='sent' if j['sent_bytes']>=j['size_bytes'] else 'transmitting';put('queue',j,j['id']) | |
| return {'transmitted_bytes':moved,'link_open':link_open,'energy_allowed':energy_allowed,'provenance':'SIMULATED LINK','items':all_records('queue')} | |
| def cloud_assessment(weather=None,baseline=None,enhanced=None): | |
| factors=[];missing=['cloud microphysics','vertical cloud structure','in-cloud temperature and liquid water','updraft observations'] | |
| if weather: | |
| times=weather.get('hourly',{}).get('time',[]) | |
| # Use provider time nearest current UTC rather than first midnight record. | |
| current=datetime.now(timezone.utc).replace(tzinfo=None) | |
| idx=min(range(len(times)),key=lambda i:abs((datetime.fromisoformat(times[i]).replace(tzinfo=None)-current).total_seconds())) if times else None | |
| for key in ('temperature_2m','relative_humidity_2m','cloud_cover','wind_speed_10m','precipitation'): | |
| values=weather.get('hourly',{}).get(key,[]) | |
| val=values[idx] if idx is not None and idx<len(values) else None | |
| factors.append({'factor':key,'value':val,'unit':weather.get('units',{}).get(key),'source':weather.get('source'), | |
| 'time':times[idx] if idx is not None else None,'status':weather.get('provenance') if val is not None else 'UNAVAILABLE', | |
| 'interpretation':'Surface/grid context only; does not establish seedability'}) | |
| difference=None | |
| if baseline and enhanced: | |
| b,e=baseline['frames'][-1],enhanced['frames'][-1] | |
| difference={'area_km2':e['area_km2']-b['area_km2'],'exposed_features':e['exposed_count']-b['exposed_count'], | |
| 'baseline_id':baseline['id'],'enhanced_id':enhanced['id'],'assumed_rain_increase_pct':(enhanced['config']['rainfall_mm_h']/baseline['config']['rainfall_mm_h']-1)*100 if baseline['config']['rainfall_mm_h'] else None} | |
| for factor in factors: | |
| if factor.get('time'): | |
| stamp=datetime.fromisoformat(factor['time'].replace('Z','+00:00')) | |
| factor['time']=(stamp.replace(tzinfo=timezone.utc) if stamp.tzinfo is None else stamp.astimezone(timezone.utc)).isoformat() | |
| return {'status':'INSUFFICIENT DATA','created_at':now(),'factors':factors,'missing':missing,'comparison':difference, | |
| 'warnings':['Additional rainfall may worsen runoff and flooding','Rainfall enhancement is a user assumption, not a prediction of cloud-seeding effectiveness','No operational recommendation or actuation; qualified atmospheric assessment required']} | |