Refine node and link operatons

main.py

@@ -1,6 +1,8 @@
+from cmath import tan
 import os
 import io
 import json
+from platform import node
 from typing import *
 from urllib.request import Request
 from fastapi import FastAPI, File, UploadFile
@@ -173,7 +175,10 @@ async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]:
 
 @app.post("/addjunction/")
 async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
-    ps = {'id' : junction, 'x' : x, 'y' : y, 'elevation' : z}
+    ps = { 'id' : junction, 
+           'x' : x, 
+           'y' : y, 
+           'elevation' : z }
     return add_junction(network, ChangeSet(ps))
 
 @app.post("/deletejunction/")
@@ -199,7 +204,8 @@ async def fastapi_get_junction_x(network: str, junction: str) -> float:
 @app.get("/getjunctioncoord/")
 async def fastapi_get_junction_coord(network: str, junction: str) -> dict[str, float]:
     ps = get_junction(network, junction)
-    coord = { 'x' : ps['x'], 'y' : ps['y']}
+    coord = { 'x' : ps['x'], 
+              'y' : ps['y'] }
     return coord
 
 @app.get("/getjunctiondemand/")
@@ -214,46 +220,40 @@ async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
 
 @app.post("/setjunctionelevation/")
 async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
-    props = {}
-    props['id'] = junction
-    props['elevation'] = elevation
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction,
+           'elevation' : elevation }
+    return set_junction(network, ChangeSet(ps))
 
 @app.post("/setjunctionx/")
 async def fastapi_set_junction_x(network: str, junction: str, x: float) -> ChangeSet:
-    props = {}
-    props['id'] = junction
-    props['x'] = x
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction,
+           'x' : x }
+    return set_junction(network, ChangeSet(ps))
     
 @app.post("/setjunctiony/")
 async def fastapi_set_junction_y(network: str, junction: str, y: float) -> ChangeSet:
-    props = {}
-    props['id'] = junction
-    props['y'] = y
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction,
+           'y' : y }
+    return set_junction(network, ChangeSet(ps))
 
 @app.post("/setjunctioncoord/")
 async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
-    props = {}
-    props['id'] = junction
-    props['x'] = x 
-    props['y'] = y
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction,
+           'x' : x,
+           'y' : y } 
+    return set_junction(network, ChangeSet(ps))
     
 @app.post("/setjunctiondemand/")
 async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
-    props = {}
-    props['id'] = junction
-    props['demand'] = demand
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction,
+           'demand' : demand }
+    return set_junction(network, ChangeSet(ps))
 
 @app.post("/setjunctionpattern/")
 async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
-    props = {}
-    props['id'] = junction
-    props['pattern'] = pattern
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction,
+           'pattern' : pattern }
+    return set_junction(network, ChangeSet(ps))
 
 @app.get("/getjunctionproperties/")
 async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]:
@@ -261,7 +261,9 @@ async def fastapi_get_junction_properties(network: str, junction: str) -> dict[s
 
 @app.post("/setjunctionproperties/")
 async def fastapi_set_junction_properties(network: str, junction: str, props: dict[str, Any]) -> ChangeSet:
-    return set_junction(network, ChangeSet(props))
+    ps = { 'id' : junction } | props
+    return set_junction(network, ChangeSet(ps))
+
 
 ############################################################
 # reservoir 3.[RESERVOIRS]
@@ -272,11 +274,16 @@ async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]:
 
 @app.post("/addreservoir/")
 async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
-    return add_reservoir(network, reservoir, x, y, head)
+    ps = { 'id' : reservoir, 
+           'x' : x, 
+           'y' : y, 
+           'head' : head }
+    return add_reservoir(network, ChangeSet(ps)) 
 
 @app.post("/deletereservoir/")
 async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
-    return delete_reservoir(network, reservoir)
+    coord = { 'id' : reservoir }
+    return delete_reservoir(network, ChangeSet(ps))
 
 @app.get("/getreservoirhead/")
 async def fastapi_get_reservoir_head(network: str, reservoir: str) -> float | None:
@@ -301,39 +308,41 @@ async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, flo
 @app.get("/getreservoircoord/")
 async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, float] | None:
     ps = get_reservoir(network, reservoir)
-    coord = { 'x' : ps['x'], 'y' : ps['y']}
+    coord = { 'id' : reservoir,
+              'x' : ps['x'], 
+              'y' : ps['y'] }
     return coord
 
 @app.post("/setreservoirhead/")
 async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
-    props = {}
-    props['head'] = head
-    return set_reservoir(network, reservoir, props)
+    ps = { 'id' : reservoir, 
+           'head' : head }
+    return set_reservoir(network, reservoir, ps)
 
 @app.post("/setreservoirpattern/")
 async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
-    props = {}
-    props['pattern'] = pattern
-    return set_reservoir(network, reservoir, props)
+    ps = { 'id' : reservoir, 
+           'pattern' : pattern }
+    return set_reservoir(network, reservoir, ps)
 
 @app.post("/setreservoirx/")
 async def fastapi_set_reservoir_x(network: str, reservoir: str, x: float) -> ChangeSet:
-    props = {}
-    props['x'] = x
-    return set_reservoir(network, reservoir, props)
+    ps = { 'id' : reservoir, 
+           'x' : x }
+    return set_reservoir(network, reservoir, ps)
 
 @app.post("/setreservoirx/")
 async def fastapi_set_reservoir_y(network: str, reservoir: str, y: float) -> ChangeSet:
-    props = {}
-    props['y'] = y
-    return set_reservoir(network, reservoir, props)
+    ps = { 'id' : reservoir, 
+           'y' : y }
+    return set_reservoir(network, reservoir, ps)
 
 @app.post("/setreservoircoord/")
 async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
-    props = {}
-    props['x'] = x
-    props['y'] = y
-    return set_reservoir(network, reservoir, props)
+    ps = { 'id' : reservoir, 
+           'x' : x,
+           'y' : y }
+    return set_reservoir(network, reservoir, ps)
 
 @app.get("/getreservoirproperties/")
 async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]:
@@ -341,7 +350,8 @@ async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict
 
 @app.post("/setreservoirproperties/")
 async def fastapi_set_reservoir_properties(network: str, reservoir: str, props: dict[str, Any]) -> ChangeSet:
-    return set_reservoir(network, reservoir, props)
+    ps = { 'id' : reservoir } | props
+    return set_reservoir(network, ChangeSet(ps))
 
 
 ############################################################
@@ -357,7 +367,8 @@ async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevatio
 
 @app.post("/deletetank/")
 async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
-    return delete_tank(network, tank)
+    ps = { 'id' : tank }
+    return delete_tank(network, ChangeSet(ps))
 
 @app.get("/gettankelevation/")
 async def fastapi_get_tank_elevation(network: str, tank: str) -> float | None:
@@ -412,75 +423,76 @@ async def fastapi_get_tank_x(network: str, tank: str) -> float:
 @app.get("/gettankcoord/")
 async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float]:
     ps = get_tank(network, tank)
-    coord = { 'x' : ps['x'], 'y' : ps['y']}
+    coord = { 'x' : ps['x'], 
+              'y' : ps['y'] }
     return coord
 
 @app.post("/settankelevation/")
 async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
-    props = {}
-    props['elevation'] = elevation
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'elevation' : elevation }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankinitlevel/")
 async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
-    props = {}
-    props['init_level'] = init_level
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'init_level' : init_level }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankminlevel/")
 async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
-    props = {}
-    props['min_level'] = min_level
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'min_level' : min_level }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankmaxlevel/")
 async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
-    props = {}
-    props['max_level'] = max_level
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'max_level' : max_level }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("settankdiameter//")
 async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
-    props = {}
-    props['diameter'] = diameter
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'diameter' : diameter }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankminvol/")
 async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
-    props = {}
-    props['min_vol'] = min_vol
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'min_vol' : min_vol }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankvolcurve/")
 async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
-    props = {}
-    props['vol_curve'] = vol_curve
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'vol_curve' : vol_curve}
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankoverflow/")
 async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
-    props = {}
-    props['overflow'] = overflow
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'overflow' : overflow }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankx/")
 async def fastapi_set_tank_x(network: str, tank: str, x: float) -> ChangeSet:
-    props = {}
-    props['x'] = x
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'x' : x }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settanky/")
 async def fastapi_set_tank_y(network: str, tank: str, y: float) -> ChangeSet:
-    props = {}
-    props['y'] = y
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'y' : y }
+    return set_tank(network, ChangeSet(ps))
 
 @app.post("/settankcoord/")
 async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
-    props = {}
-    props['x'] = x
-    props['y'] = y
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank,
+           'x' : x, 
+           'y' : y }
+    return set_tank(network, ChangeSet(ps))
 
 @app.get("/gettankproperties/")
 async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]:
@@ -488,7 +500,8 @@ async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]
 
 @app.post("/settankproperties/")
 async def fastapi_set_tank_properties(network: str, tank: str, props: dict[str, Any]) -> ChangeSet:
-    return set_tank(network, tank, props)
+    ps = { 'id' : tank } | props
+    return set_tank(network, ChangeSet(ps))
 
 
 ############################################################
@@ -500,16 +513,15 @@ async def fast_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]:
 
 @app.post("/addpipe/")
 async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0, diameter: float = 0, roughness: float = 0, minorloss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
-    props : dict[str, any] = {}
-    props['id'] = pipe
-    props['node1'] = node1
-    props['node2'] = node2
-    props['length'] = length
-    props['diameter'] = diameter
-    props['roughness'] = roughness
-    props['minor_loss'] = minorloss
-    props['status'] = status
-    return add_pipe(network, ChangeSet(props))
+    ps = { 'id' : pipe,
+           'node1' : node1,
+           'node2' : node2,
+           'length' : length,
+           'diameter' : diameter,
+           'roughness' : roughness,
+           'minor_loss' : minorloss,
+           'status' : status }   
+    return add_pipe(network, ChangeSet(ps))
 
 @app.post("/deletepipe/")
 async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
@@ -553,43 +565,45 @@ async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
 
 @app.post("/setpipenode1/")
 async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
-    ps = get_pipe(network, pipe)
-    return ps['node1']
+    ps = { 'id' : pipe,
+           'node1' : node1 }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.post("/setpipenode2/")
 async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
-    ps = get_pipe(network, pipe)
-    return ps['node2']
+    ps = { 'id' : pipe,
+           'node2' : node2 }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.post("/setpipelength/")
 async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
-    props = {}
-    props['length'] = length
-    return set_pipe(network, pipe, props)
+    ps = { 'id' : pipe,
+           'length' : length }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.post("/setpipediameter/")
 async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
-    props = {}
-    props['diameter'] = diameter
-    return set_pipe(network, pipe, props)
+    ps = { 'id' : pipe,
+           'diameter' : diameter }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.post("/setpiperoughness/")
 async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
-    props = {}
-    props['roughness'] = roughness
-    return set_pipe(network, pipe, props)
+    ps = { 'id' : pipe,
+           'roughness' : roughness }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.post("/setpipeminorloss/")
 async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
-    props = {}
-    props['minor_loss'] = minor_loss
-    return set_pipe(network, pipe, props)
+    ps = { 'id' : pipe,
+           'minor_loss' : minor_loss }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.post("/setpipestatus/")
 async def fastapi_set_pipe_status(network: str, pipe: str, status: float) -> ChangeSet:
-    props = {}
-    props['status'] = status
-    return set_pipe(network, pipe, props)
+    ps = { 'id' : pipe,
+           'status' : status }
+    return set_pipe(network, ChangeSet(ps))
 
 @app.get("/getpipeproperties/")
 async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]:
@@ -597,8 +611,9 @@ async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]
 
 @app.post("/setpipeproperties/")
 async def fastapi_set_pipe_properties(network: str, pipe: str, props: dict[str, Any]) -> ChangeSet:
-    return set_pipe(network, pipe, props)
-
+    ps = { 'id' : pipe } | props
+    return set_pipe(network, ChangeSet(ps))
+    
 
 ############################################################
 # pump 4.[PUMPS]
@@ -609,16 +624,15 @@ async def fast_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
 
 @app.post("/addpump/")
 async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str) -> ChangeSet:
-    props: dict[str, any] = {
-        'id' : pump,
-        'node1' : node1,
-        'node2' : node2
-    }
-    return add_pump(network, ChangeSet(props))
+    ps = { 'id' : pump,
+           'node1' : node1,
+           'node2' : node2 }
+    return add_pump(network, ChangeSet(ps))
 
 @app.post("/deletepump/")
 async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
-    return delete_pump(network, pump)
+    ps = { 'id' : pump } 
+    return delete_pump(network, ChangeSet(ps)) 
 
 @app.get("/getpumpnode1/")
 async def fastapi_get_pump_node1(network: str, pump: str) -> str | None:
@@ -632,15 +646,15 @@ async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
 
 @app.post("/setpumpnode1/")
 async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
-    props = {}
-    props['node1'] = node1
-    return set_pump(network, pump, props)
+    ps = { 'id' : pump,
+           'node1' : node1 } 
+    return set_pump(network, ChangeSet(ps))
 
 @app.post("/setpumpnode2/")
 async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
-    props = {}
-    props['node2'] = node2
-    return set_pump(network, pump, props)
+    ps = { 'id' : pump,
+           'node2' : node2 } 
+    return set_pump(network, ChangeSet(ps))
 
 @app.get("/getpumpproperties/")
 async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]:
@@ -648,8 +662,9 @@ async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]
 
 @app.post("/setpumpproperties/")
 async def fastapi_set_pump_properties(network: str, pump: str, props: dict[str, Any]) -> ChangeSet:
-    return set_pump(network, pump, props)
-    
+    ps = { 'id' : pump } | props
+    return set_pump(network, ChangeSet(ps)) 
+
 
 ############################################################
 # valve 4.[VALVES]
@@ -664,7 +679,8 @@ async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, di
 
 @app.post("/deletevalve/")
 async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
-    return delete_valve(network, valve)
+    ps = { 'id' : valve } 
+    return delete_valve(network, ChangeSet(ps)) 
 
 @app.get("/getvalvenode1/")
 async def fastapi_get_valve_node1(network: str, valve: str) -> str | None:
@@ -698,33 +714,33 @@ async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None
 
 @app.post("/setvalvenode1/")
 async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
-    props = {}
-    props['node1'] = node1
-    return set_valve(network, valve, props)
+    ps = { 'id' : valve,
+           'node1' : node1 } 
+    return set_valve(network, ChangeSet(ps))
 
 @app.post("/setvalvenode2/")
 async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
-    props = {}
-    props['node2'] = node2
-    return set_valve(network, valve, props)
+    ps = { 'id' : valve,
+           'node2' : node2 } 
+    return set_valve(network, ChangeSet(ps))
 
 @app.post("/setvalvenodediameter/")
 async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
-    props = {}
-    props['diameter'] = diameter
-    return set_valve(network, valve, props)
+    ps = { 'id' : valve,
+           'diameter' : diameter } 
+    return set_valve(network, ChangeSet(ps))
 
 @app.post("/setvalvetype/")
 async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
-    props = {}
-    props['type'] = type
-    return set_valve(network, valve, props)
+    ps = { 'id' : valve,
+           'type' : type } 
+    return set_valve(network, ChangeSet(ps))
 
 @app.post("/setvalvesetting/")
 async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
-    props = {}
-    props['setting'] = setting
-    return set_valve(network, valve, props)
+    ps = { 'id' : valve,
+           'setting' : setting } 
+    return set_valve(network, ChangeSet(ps))
 
 @app.get("/getvalveproperties/")
 async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]:
@@ -732,7 +748,8 @@ async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, An
 
 @app.post("/setvalveproperties/")
 async def fastapi_set_valve_properties(network: str, valve: str, props: dict[str, Any]) -> ChangeSet:
-    return set_valve(network, valve, props)
+    ps = { 'id' : valve } | props
+    return set_valve(network, ChangeSet(ps))