Refine main.py

main.py

@@ -1,5 +1,4 @@
-from itertools import count
-from netrc import netrc
+from asyncio.windows_utils import pipe
 import os
 import io
 from typing import *
@@ -196,31 +195,24 @@ async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
 async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
     props = {}
     props['elevation'] = elevation
-
     return set_junction(network, junction, props)
 
 @app.post("/setjunctioncoord/")
 async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
     props = {}
-    coord = {}
-    coord['x'] = x
-    coord['y'] = y
-    props['coord'] = coord
-
+    props['coord'] = {'x' : x, 'y' : y}
     return set_junction(network, junction, props)
     
 @app.post("/setjunctiondemand/")
 async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
     props = {}
     props['demand'] = demand
-
     return set_junction(network, junction, props)
 
 @app.post("/setjunctionpattern/")
 async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
     props = {}
     props['pattern'] = pattern
-
     return set_junction(network, junction, props)
 
 @app.get("/getjunctionproperties/")
@@ -245,30 +237,36 @@ async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
 
 @app.get("/getreservoirhead/")
 async def fastapi_get_reservoir_head(network: str, reservoir: str) -> float | None:
-    ps = get_reservoir_properties(network, reservoir)
+    ps = get_reservoir(network, reservoir)
     return ps['head']
 
 @app.get("/getreservoirpattern/")
 async def fastapi_get_reservoir_pattern(network: str, reservoir: str) -> str | None:
-    ps = get_reservoir_properties(network, reservoir)
+    ps = get_reservoir(network, reservoir)
     return ps['pattern']
 
 @app.get("/getreservoircoord/")
 async def fastapi_get_reservoir_coord(network: str, reservoir: str) -> dict[str, float] | None:
-    ps = get_reservoir_properties(network, reservoir)
+    ps = get_reservoir(network, reservoir)
     return ps['coord']
 
 @app.post("/setreservoirhead/")
 async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
-    return set_reservoir_head(network, reservoir, head)
+    props = {}
+    props['head'] = head
+    return set_reservoir(network, reservoir, props)
 
 @app.post("/setreservoirpattern/")
 async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
-    return set_reservoir_pattern(network, reservoir, pattern)
+    props = {}
+    props['pattern'] = pattern
+    return set_reservoir(network, reservoir, props)
 
 @app.post("/setreservoircoord/")
 async def fastapi_set_reservoir_coord(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
-    return set_reservoir_coord(network, reservoir, x, y)
+    props = {}
+    props['coord'] = {'x' : x, 'y' : y}
+    return set_reservoir(network, reservoir, props)
 
 
 ############################################################
@@ -285,84 +283,102 @@ 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:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['elevation']
 
 @app.get("/gettankinitlevel/")
 async def fastapi_get_tank_init_level(network: str, tank: str) -> float | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['init_level']
 
 @app.get("/gettankminlevel/")
 async def fastapi_get_tank_min_level(network: str, tank: str) -> float | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['min_level']
 
 @app.get("/gettankmaxlevel/")
 async def fastapi_get_tank_max_level(network: str, tank: str) -> float | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['max_level']
 
 @app.get("/gettankdiameter/")
 async def fastapi_get_tank_diameter(network: str, tank: str) -> float | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['diameter']
 
 @app.get("/gettankminvol/")
 async def fastapi_get_tank_min_vol(network: str, tank: str) -> float | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['min_vol'] 
 
 @app.get("/gettankvolcurve/")
 async def fastapi_get_tank_vol_curve(network: str, tank: str) -> str | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['vol_curve']
 
 @app.get("/gettankoverflow/")
 async def fastapi_get_tank_overflow(network: str, tank: str) -> str | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['overflow']
 
 @app.get("/gettankcoord/")
 async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float] | None:
-    ps = get_tank_properties(network, tank)
+    ps = get_tank(network, tank)
     return ps['coord']
 
 @app.post("/settankelevation/")
 async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
-    return set_tank_elevation(network, tank, elevation)
+    props = {}
+    props['elevation'] = elevation
+    return set_tank(network, tank, props)
 
 @app.post("/settankinitlevel/")
 async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
-    return set_tank_init_level(network, tank, init_level)
+    props = {}
+    props['init_level'] = init_level
+    return set_tank(network, tank, props)
 
 @app.post("/settankminlevel/")
 async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
-    return set_tank_min_level(network, tank, min_level)
+    props = {}
+    props['min_level'] = min_level
+    return set_tank(network, tank, props)
 
 @app.post("/settankmaxlevel/")
 async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
-    return set_tank_max_level(network, tank, max_level)
+    props = {}
+    props['max_level'] = max_level
+    return set_tank(network, tank, props)
 
 @app.post("settankdiameter//")
 async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
-    return set_tank_diameter(network, tank, diameter)
+    props = {}
+    props['diameter'] = diameter
+    return set_tank(network, tank, props)
 
 @app.post("/settankminvol/")
 async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
-    return set_tank_min_vol(network, tank, min_vol)
+    props = {}
+    props['min_vol'] = min_vol
+    return set_tank(network, tank, props)
 
 @app.post("/settankvolcurve/")
 async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
-    return set_tank_vol_curve(network, tank, vol_curve)
+    props = {}
+    props['vol_curve'] = vol_curve
+    return set_tank(network, tank, props)
 
 @app.post("/settankoverflow/")
 async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
-    return set_tank_overflow(network, tank, overflow)
+    props = {}
+    props['overflow'] = overflow
+    return set_tank(network, tank, props)
 
 @app.post("/settankcoord/")
 async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
-    return set_tank_coord(network, tank, x, y)
+    props = {}
+    props['coord'] = {'x' : x, 'y' : y}
+    return set_tank(network, tank, props)
 
 ############################################################
 # pipe 4.[PIPES]
@@ -378,70 +394,78 @@ async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
 
 @app.get("/getpipenode1/")
 async def fastapi_get_pipe_node1(network: str, pipe: str) -> str | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['node1']
 
 @app.get("/getpipenode2/")
 async def fastapi_get_pipe_node2(network: str, pipe: str) -> str | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['node2']
 
 @app.get("/getpipelength/")
 async def fastapi_get_pipe_length(network: str, pipe: str) -> float | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['length']
 
 @app.get("/getpipediameter/")
 async def fastapi_get_pipe_diameter(network: str, pipe: str) -> float | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['diameter']
 
 @app.get("/getpiperoughness/")
 async def fastapi_get_pipe_roughness(network: str, pipe: str) -> float | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['roughness']
 
 @app.get("/getpipeminorloss/")
 async def fastapi_get_pipe_minor_loss(network: str, pipe: str) -> float | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['minor_loss']
 
 @app.get("/getpipestatus/")
 async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['status']
 
 @app.post("/setpipenode1/")
 async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['node1']
 
 @app.post("/setpipenode2/")
 async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
-    ps = get_pipe_properties(network, pipe)
+    ps = get_pipe(network, pipe)
     return ps['node2']
 
 @app.post("/setpipelength/")
 async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
-    ps = get_pipe_properties(network, pipe)
-    return ps['length']
+    props = {}
+    props['length'] = length
+    return set_pipe(network, pipe, props)
 
 @app.post("/setpipediameter/")
 async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
-    ps = get_pipe_properties(network, pipe)
-    return ps['diameter']
+    props = {}
+    props['diameter'] = diameter
+    return set_pipe(network, pipe, props)
 
 @app.post("/setpiperoughness/")
 async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
-    return set_pipe_roughness(network, pipe, roughness)
+    props = {}
+    props['roughness'] = roughness
+    return set_pipe(network, pipe, props)
 
 @app.post("/setpipeminorloss/")
 async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
-    return set_pipe_minor_loss(network, pipe, minor_loss)
+    props = {}
+    props['minor_loss'] = minor_loss
+    return set_pipe(network, pipe, props)
 
 @app.post("/setpipestatus/")
 async def fastapi_set_pipe_status(network: str, pipe: str, status: float) -> ChangeSet:
-    return set_pipe_status(network, pipe, status)
+    props = {}
+    props['status'] = status
+    return set_pipe(network, pipe, props)
 
 
 ############################################################
@@ -458,22 +482,25 @@ 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:
-    ps = get_pump_properties(network, pump)
+    ps = get_pump(network, pump)
     return ps['node1']
 
 @app.get("/getpumpnode2/")
 async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
-    ps = get_pump_properties(network, pump)
+    ps = get_pump(network, pump)
     return ps['node2']
 
 @app.post("/setpumpnode1/")
 async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
-    return set_pump_node1(network, pump, node1)
+    props = {}
+    props['node1'] = node1
+    return set_pump(network, pump, props)
 
 @app.post("/setpumpnode2/")
 async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
-    return set_pump_node2(network, pump, node2)
-
+    props = {}
+    props['node2'] = node2
+    return set_pump(network, pump, props)
 
 ############################################################
 # valve 4.[VALVES]
@@ -489,55 +516,63 @@ 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:
-    ps = get_valve_properties(network, valve)
+    ps = get_valve(network, valve)
     return ps['node1']
 
 @app.get("/getvalvenode2/")
 async def fastapi_get_valve_node2(network: str, valve: str) -> str | None:
-    ps = get_valve_properties(network, valve)
+    ps = get_valve(network, valve)
     return ps['node2']
 
 @app.get("/getvalvediameter/")
 async def fastapi_get_valve_diameter(network: str, valve: str) -> float | None:
-    ps = get_valve_properties(network, valve)
+    ps = get_valve(network, valve)
     return ps['diameter']
 
 @app.get("/getvalvetype/")
 async def fastapi_get_valve_type(network: str, valve: str) -> str | None:
-    ps = get_valve_properties(network, valve)
+    ps = get_valve(network, valve)
     return ps['type']
 
 @app.get("/getvalvesetting/")
 async def fastapi_get_valve_setting(network: str, valve: str) -> float | None:
-    ps = get_valve_properties(network, valve)
+    ps = get_valve(network, valve)
     return ps['setting']
 
 @app.get("/getvalveminorloss/")
 async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None:
-    ps = get_valve_properties(network, valve)
+    ps = get_valve(network, valve)
     return ps['minor_loss']
 
 @app.post("/setvalvenode1/")
 async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
-    return set_valve_node1(network, valve, node1)
+    props = {}
+    props['node1'] = node1
+    return set_valve(network, valve, props)
 
 @app.post("/setvalvenode2/")
 async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
-    return set_valve_node2(network, valve, node2)
+    props = {}
+    props['node2'] = node2
+    return set_valve(network, valve, props)
 
 @app.post("/setvalvenodediameter/")
 async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
-    return set_valve_diameter(network, valve, diameter)
+    props = {}
+    props['diameter'] = diameter
+    return set_valve(network, valve, props)
 
 @app.post("/setvalvetype/")
 async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
-    return set_valve_type(network, valve, type)
+    props = {}
+    props['type'] = type
+    return set_valve(network, valve, props)
 
 @app.post("/setvalvesetting/")
 async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
-    return set_valve_setting(network, valve, setting)
-
-
+    props = {}
+    props['setting'] = setting
+    return set_valve(network, valve, props)
 
 # inp file
 @app.post("/uploadinp/", status_code=status.HTTP_200_OK)