Refine fastapi api

main.py

@@ -158,19 +158,23 @@ async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
 
 @app.get("/getjunctionelevation/")
 async def fastapi_get_junction_elevation(network: str, junction: str) -> float:
-    return get_junction_elevation(network, junction)
+    ps = get_junction_properties(network, junction)
+    return ps['elevation']
 
 @app.get("/getjunctioncoord/")
 async def fastapi_get_junction_coord(network: str, junction: str) -> dict[str, float]:
-    return get_junction_coord(network, junction)
+    ps = get_junction_properties(network, junction)
+    return ps['coord']
 
 @app.get("/getjunctiondemand/")
 async def fastapi_get_junction_demand(network: str, junction: str) -> float:
-    return get_junction_demand(network, junction)
+    ps = get_junction_properties(network, junction)
+    return ps['demand']
 
 @app.get("/getjunctionpattern/")
 async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
-    return get_junction_pattern(network, junction)
+    ps = get_junction_properties(network, junction)
+    return ps['pattern']
 
 @app.post("/setjunctionelevation/")
 async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
@@ -208,7 +212,8 @@ async def fastapi_get_reservoir_head(network: str, reservoir: str) -> float | No
 
 @app.get("/getreservoirpattern/")
 async def fastapi_get_reservoir_pattern(network: str, reservoir: str) -> str | None:
-    return get_reservoir_pattern(network, reservoir)
+    ps = get_reservoir_properties(network, reservoir)
+    return ps['pattern']
 
 @app.get("/getreservoircoord/")
 async def fastapi_get_reservoir_coord(network: str, reservoir: str) -> dict[str, float] | None:
@@ -242,39 +247,48 @@ async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
 
 @app.get("/gettankelevation/")
 async def fastapi_get_tank_elevation(network: str, tank: str) -> float | None:
-    return get_tank_elevation(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['elevation']
 
 @app.get("/gettankinitlevel/")
 async def fastapi_get_tank_init_level(network: str, tank: str) -> float | None:
-    return get_tank_init_level(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['init_level']
 
 @app.get("/gettankminlevel/")
 async def fastapi_get_tank_min_level(network: str, tank: str) -> float | None:
-    return get_tank_min_level(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['min_level']
 
 @app.get("/gettankmaxlevel/")
 async def fastapi_get_tank_max_level(network: str, tank: str) -> float | None:
-    return get_tank_max_level(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['max_level']
 
 @app.get("/gettankdiameter/")
 async def fastapi_get_tank_diameter(network: str, tank: str) -> float | None:
-    return get_tank_diameter(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['diameter']
 
 @app.get("/gettankminvol/")
 async def fastapi_get_tank_min_vol(network: str, tank: str) -> float | None:
-    return get_tank_min_vol(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['min_vol'] 
 
 @app.get("/gettankvolcurve/")
 async def fastapi_get_tank_vol_curve(network: str, tank: str) -> str | None:
-    return get_tank_vol_curve(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['vol_curve']
 
 @app.get("/gettankoverflow/")
 async def fastapi_get_tank_overflow(network: str, tank: str) -> str | None:
-    return get_tank_overflow(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['overflow']
 
 @app.get("/gettankcoord/")
 async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float] | None:
-    return get_tank_coord(network, tank)
+    ps = get_tank_properties(network, tank)
+    return ps['coord']
 
 @app.post("/settankelevation/")
 async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
@@ -325,60 +339,71 @@ async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
     return delete_pipe(network, pipe)
 
 @app.get("/getpipenode1/")
-async def fastapi_get_pipe_node1(name: str, pipe: str) -> str | None:
-    return get_pipe_node1(name, pipe)
+async def fastapi_get_pipe_node1(network: str, pipe: str) -> str | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['node1']
 
 @app.get("/getpipenode2/")
-async def fastapi_get_pipe_node2(name: str, pipe: str) -> str | None:
-    return get_pipe_node2(name, pipe)
+async def fastapi_get_pipe_node2(network: str, pipe: str) -> str | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['node2']
 
 @app.get("/getpipelength/")
-async def fastapi_get_pipe_length(name: str, pipe: str) -> float | None:
-    return get_pipe_length(name, pipe)
+async def fastapi_get_pipe_length(network: str, pipe: str) -> float | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['length']
 
 @app.get("/getpipediameter/")
-async def fastapi_get_pipe_diameter(name: str, pipe: str) -> float | None:
-    return get_pipe_diameter(name, pipe)
+async def fastapi_get_pipe_diameter(network: str, pipe: str) -> float | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['diameter']
 
 @app.get("/getpiperoughness/")
-async def fastapi_get_pipe_roughness(name: str, pipe: str) -> float | None:
-    return get_pipe_roughness(name, pipe)
+async def fastapi_get_pipe_roughness(network: str, pipe: str) -> float | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['roughness']
 
 @app.get("/getpipeminorloss/")
-async def fastapi_get_pipe_minor_loss(name: str, pipe: str) -> float | None:
-    return get_pipe_minor_loss(name, pipe)
+async def fastapi_get_pipe_minor_loss(network: str, pipe: str) -> float | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['minor_loss']
 
 @app.get("/getpipestatus/")
-async def fastapi_get_pipe_status(name: str, pipe: str) -> str | None:
-    return get_pipe_status(name, pipe)
+async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
+    ps = get_pipe_properties(network, pipe)
+    return ps['status']
 
 @app.post("/setpipenode1/")
-async def fastapi_set_pipe_node1(name: str, pipe: str, node1: str) -> ChangeSet:
-    return set_pipe_node1(name, pipe, node1)
+async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
+    ps = get_pipe_properties(network, pipe)
+    return ps['node1']
 
 @app.post("/setpipenode2/")
-async def fastapi_set_pipe_node2(name: str, pipe: str, node2: str) -> ChangeSet:
-    return set_pipe_node2(name, pipe, node2)
+async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
+    ps = get_pipe_properties(network, pipe)
+    return ps['node2']
 
 @app.post("/setpipelength/")
-async def fastapi_set_pipe_length(name: str, pipe: str, length: float) -> ChangeSet:
-    return set_pipe_length(name, pipe, length)
+async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
+    ps = get_pipe_properties(network, pipe)
+    return ps['length']
 
 @app.post("/setpipediameter/")
-async def fastapi_set_pipe_diameter(name: str, pipe: str, diameter: float) -> ChangeSet:
-    return set_pipe_diameter(name, pipe, diameter)
+async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
+    ps = get_pipe_properties(network, pipe)
+    return ps['diameter']
 
 @app.post("/setpiperoughness/")
-async def fastapi_set_pipe_roughness(name: str, pipe: str, roughness: float) -> ChangeSet:
-    return set_pipe_roughness(name, pipe, roughness)
+async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
+    return set_pipe_roughness(network, pipe, roughness)
 
 @app.post("/setpipeminorloss/")
-async def fastapi_set_pipe_minor_loss(name: str, pipe: str, minor_loss: float) -> ChangeSet:
-    return set_pipe_minor_loss(name, pipe, minor_loss)
+async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
+    return set_pipe_minor_loss(network, pipe, minor_loss)
 
 @app.post("/setpipestatus/")
-async def fastapi_set_pipe_status(name: str, pipe: str, status: float) -> ChangeSet:
-    return set_pipe_status(name, pipe, status)
+async def fastapi_set_pipe_status(network: str, pipe: str, status: float) -> ChangeSet:
+    return set_pipe_status(network, pipe, status)
 
 
 ############################################################
@@ -395,11 +420,13 @@ async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
 
 @app.get("/getpumpnode1/")
 async def fastapi_get_pump_node1(network: str, pump: str) -> str | None:
-    return get_pump_node1(network, pump)
+    ps = get_pump_properties(network, pump)
+    return ps['node1']
 
 @app.get("/getpumpnode2/")
 async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
-    return get_pump_node2(network, pump)
+    ps = get_pump_properties(network, pump)
+    return ps['node2']
 
 @app.post("/setpumpnode1/")
 async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
@@ -424,27 +451,33 @@ async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
 
 @app.get("/getvalvenode1/")
 async def fastapi_get_valve_node1(network: str, valve: str) -> str | None:
-    return get_valve_node1(network, valve)
+    ps = get_valve_properties(network, valve)
+    return ps['node1']
 
 @app.get("/getvalvenode2/")
 async def fastapi_get_valve_node2(network: str, valve: str) -> str | None:
-    return get_valve_node2(network, valve)
+    ps = get_valve_properties(network, valve)
+    return ps['node2']
 
 @app.get("/getvalvediameter/")
 async def fastapi_get_valve_diameter(network: str, valve: str) -> float | None:
-    return get_valve_diameter(network, valve)
+    ps = get_valve_properties(network, valve)
+    return ps['diameter']
 
 @app.get("/getvalvetype/")
 async def fastapi_get_valve_type(network: str, valve: str) -> str | None:
-    return get_valve_type(network, valve)
+    ps = get_valve_properties(network, valve)
+    return ps['type']
 
 @app.get("/getvalvesetting/")
 async def fastapi_get_valve_setting(network: str, valve: str) -> float | None:
-    return get_valve_setting(network, valve)
+    ps = get_valve_properties(network, valve)
+    return ps['setting']
 
 @app.get("/getvalveminorloss/")
 async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None:
-    return get_valve_minor_loss(network, valve)
+    ps = get_valve_properties(network, valve)
+    return ps['minor_loss']
 
 @app.post("/setvalvenode1/")
 async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet: