OrgTJWater/TJWaterServer
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

to solve the encoding problem of inp file exchange

Browse Source
This commit is contained in:
xinzish
2024-04-07 09:36:12 +08:00
parent 44edeffad9
commit e1b1f8d8ce
8 changed files with 2006 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
build_pyd.py
View File

@@ -2,6 +2,7 @@ from distutils.core import setup
from Cython.Build import cythonize from Cython.Build import cythonize
setup(ext_modules=cythonize([ setup(ext_modules=cythonize([
"main.py",
"tjnetwork.py", "tjnetwork.py",
"api/*.py", "api/*.py",
"epanet/*.py" "epanet/*.py"

4
demo.py Normal file
View File

@@ -0,0 +1,4 @@
from tjnetwork import *
print(list_project())

0
get_current_total_Q.py Normal file
View File

58
get_realValue.py Normal file
View File

@@ -0,0 +1,58 @@
import requests
from datetime import datetime
import pytz
def convert_to_beijing_time(utc_time_str):
# 解析UTC时间字符串为datetime对象
utc_time = datetime.strptime(utc_time_str, '%Y-%m-%dT%H:%M:%SZ')
# 设定UTC时区
utc_timezone = pytz.timezone('UTC')
# 转换为北京时间
beijing_timezone = pytz.timezone('Asia/Shanghai')
beijing_time = utc_time.replace(tzinfo=utc_timezone).astimezone(beijing_timezone)
return beijing_time
def get_realValue(ids):
# 数据接口的地址
url = 'http://183.64.62.100:9057/loong/api/mpoints/realValue'
# 设置GET请求的参数
params = {
'ids': ids
}
try:
# 发送GET请求获取数据
response = requests.get(url, params=params)
# 检查响应状态码，200表示请求成功
if response.status_code == 200:
# 解析响应的JSON数据
data = response.json()
# 只打印'id'、'datadt'和'realValue'数据
for realValue in data:
print("id:", realValue['id'])
print("mpointName:",realValue['mpointName'])
# print("datadt:", realValue['datadt'])
# 转换datadt字段为北京时间
beijing_time = convert_to_beijing_time(realValue['datadt'])
print("datadt (Beijing Time):", beijing_time.strftime('%Y-%m-%d %H:%M:%S'))
print("realValue:", realValue['realValue'])
print() # 打印空行分隔不同条目
else:
# 如果请求不成功，打印错误信息
print("请求失败，状态码:", response.status_code)
except Exception as e:
# 捕获异常
print("发生异常:", e)
# 使用示例
get_realValue(ids='2498,2500')

1808
main - 副本.py Normal file
View File

File diff suppressed because it is too large Load Diff

259
main.py
View File

@@ -56,7 +56,7 @@ async def fastapi_get_all_extension_data(network: str) -> dict[str, Any]:
async def fastapi_get_extension_data(network: str, key: str) -> str | None: async def fastapi_get_extension_data(network: str, key: str) -> str | None:
return get_extension_data(network, key) return get_extension_data(network, key)
@app.post('/setextensiondata') @app.post('/setextensiondata',response_model=None)
async def fastapi_set_extension_data(network: str, req: Request) -> ChangeSet: async def fastapi_set_extension_data(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
print(props) print(props)
@@ -116,7 +116,7 @@ async def fastapi_import_inp(network: str, req: Request):
print(ret) print(ret)
return ret return ret
@app.get("/exportinp/") @app.get("/exportinp/",response_model=None)
async def fastapi_export_inp(network: str, version: str) -> ChangeSet: async def fastapi_export_inp(network: str, version: str) -> ChangeSet:
cs = export_inp(network, version) cs = export_inp(network, version)
op = cs.operations[0] op = cs.operations[0]
@@ -160,9 +160,9 @@ async def fastapi_run_project(network: str) -> str:
raise HTTPException(status_code=409, detail="is in simulation") raise HTTPException(status_code=409, detail="is in simulation")
else: else:
print('file doesnt exists') print('file doesnt exists')
os.rename(filename, filename2) #os.rename(filename, filename2)
result = run_project(network) result = run_project(network)
os.rename(filename2, filename) #os.rename(filename2, filename)
return result return result
# put in inp folder, name without extension # put in inp folder, name without extension
@@ -251,19 +251,19 @@ async def fastapi_take_snapshot_for_current_operation(network: str, tag: str) ->
def fastapi_take_snapshot(network: str, tag: str) -> None: def fastapi_take_snapshot(network: str, tag: str) -> None:
return take_snapshot(network, tag) return take_snapshot(network, tag)
@app.post('/picksnapshot/') @app.post('/picksnapshot/',response_model=None)
def fastapi_pick_snapshot(network: str, tag: str, discard: bool = False) -> ChangeSet: def fastapi_pick_snapshot(network: str, tag: str, discard: bool = False) -> ChangeSet:
return pick_snapshot(network, tag, discard) return pick_snapshot(network, tag, discard)
@app.post('/pickoperation/') @app.post('/pickoperation/',response_model=None)
async def fastapi_pick_operation(network: str, operation: int, discard: bool = False) -> ChangeSet: async def fastapi_pick_operation(network: str, operation: int, discard: bool = False) -> ChangeSet:
return pick_operation(network, operation, discard) return pick_operation(network, operation, discard)
@app.get("/syncwithserver/") @app.get("/syncwithserver/",response_model=None)
async def fastapi_sync_with_server(network: str, operation: int) -> ChangeSet: async def fastapi_sync_with_server(network: str, operation: int) -> ChangeSet:
return sync_with_server(network, operation) return sync_with_server(network, operation)
@app.post("/batch/") @app.post("/batch/",response_model=None)
async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet: async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet:
jo_root = await req.json() jo_root = await req.json()
cs: ChangeSet = ChangeSet() cs: ChangeSet = ChangeSet()
@@ -271,7 +271,7 @@ async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet
rcs = execute_batch_commands(network, cs) rcs = execute_batch_commands(network, cs)
return rcs return rcs
@app.post("/compressedbatch/") @app.post("/compressedbatch/",response_model=None)
async def fastapi_execute_compressed_batch_commands(network: str, req: Request)-> ChangeSet: async def fastapi_execute_compressed_batch_commands(network: str, req: Request)-> ChangeSet:
jo_root = await req.json() jo_root = await req.json()
cs: ChangeSet = ChangeSet() cs: ChangeSet = ChangeSet()
@@ -361,7 +361,7 @@ async def fast_get_title_schema(network: str) -> dict[str, dict[str, Any]]:
async def fast_get_title(network: str) -> dict[str, Any]: async def fast_get_title(network: str) -> dict[str, Any]:
return get_title(network) return get_title(network)
@app.get('/settitle/') @app.get('/settitle/',response_model=None)
async def fastapi_set_title(network: str, req: Request) -> ChangeSet: async def fastapi_set_title(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_title(network, ChangeSet(props)) return set_title(network, ChangeSet(props))
@@ -373,7 +373,7 @@ async def fastapi_set_title(network: str, req: Request) -> ChangeSet:
async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]: async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]:
return get_junction_schema(network) return get_junction_schema(network)
@app.post("/addjunction/") @app.post("/addjunction/",response_model=None)
async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet: async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'x' : x, 'x' : x,
@@ -381,7 +381,7 @@ async def fastapi_add_junction(network: str, junction: str, x: float, y: float,
'elevation' : z } 'elevation' : z }
return add_junction(network, ChangeSet(ps)) return add_junction(network, ChangeSet(ps))
@app.post("/deletejunction/") @app.post("/deletejunction/",response_model=None)
async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet: async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
ps = {'id' : junction} ps = {'id' : junction}
return delete_junction(network, ChangeSet(ps)) return delete_junction(network, ChangeSet(ps))
@@ -418,38 +418,38 @@ async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
ps = get_junction(network, junction) ps = get_junction(network, junction)
return ps['pattern'] return ps['pattern']
@app.post("/setjunctionelevation/") @app.post("/setjunctionelevation/",response_model=None)
async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet: async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'elevation' : elevation } 'elevation' : elevation }
return set_junction(network, ChangeSet(ps)) return set_junction(network, ChangeSet(ps))
@app.post("/setjunctionx/") @app.post("/setjunctionx/",response_model=None)
async def fastapi_set_junction_x(network: str, junction: str, x: float) -> ChangeSet: async def fastapi_set_junction_x(network: str, junction: str, x: float) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'x' : x } 'x' : x }
return set_junction(network, ChangeSet(ps)) return set_junction(network, ChangeSet(ps))
@app.post("/setjunctiony/") @app.post("/setjunctiony/",response_model=None)
async def fastapi_set_junction_y(network: str, junction: str, y: float) -> ChangeSet: async def fastapi_set_junction_y(network: str, junction: str, y: float) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'y' : y } 'y' : y }
return set_junction(network, ChangeSet(ps)) return set_junction(network, ChangeSet(ps))
@app.post("/setjunctioncoord/") @app.post("/setjunctioncoord/",response_model=None)
async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet: async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'x' : x, 'x' : x,
'y' : y } 'y' : y }
return set_junction(network, ChangeSet(ps)) return set_junction(network, ChangeSet(ps))
@app.post("/setjunctiondemand/") @app.post("/setjunctiondemand/",response_model=None)
async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet: async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'demand' : demand } 'demand' : demand }
return set_junction(network, ChangeSet(ps)) return set_junction(network, ChangeSet(ps))
@app.post("/setjunctionpattern/") @app.post("/setjunctionpattern/",response_model=None)
async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet: async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
ps = { 'id' : junction, ps = { 'id' : junction,
'pattern' : pattern } 'pattern' : pattern }
@@ -459,7 +459,7 @@ async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str
async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]: async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]:
return get_junction(network, junction) return get_junction(network, junction)
@app.post("/setjunctionproperties/") @app.post("/setjunctionproperties/",response_model=None)
async def fastapi_set_junction_properties(network: str, junction: str, req: Request) -> ChangeSet: async def fastapi_set_junction_properties(network: str, junction: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : junction } | props ps = { 'id' : junction } | props
@@ -472,7 +472,7 @@ async def fastapi_set_junction_properties(network: str, junction: str, req: Requ
async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]: async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]:
return get_reservoir_schema(network) return get_reservoir_schema(network)
@app.post("/addreservoir/") @app.post("/addreservoir/",response_model=None)
async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet: async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
ps = { 'id' : reservoir, ps = { 'id' : reservoir,
'x' : x, 'x' : x,
@@ -480,7 +480,7 @@ async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float
'head' : head } 'head' : head }
return add_reservoir(network, ChangeSet(ps)) return add_reservoir(network, ChangeSet(ps))
@app.post("/deletereservoir/") @app.post("/deletereservoir/",response_model=None)
async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet: async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
ps = { 'id' : reservoir } ps = { 'id' : reservoir }
return delete_reservoir(network, ChangeSet(ps)) return delete_reservoir(network, ChangeSet(ps))
@@ -513,31 +513,31 @@ async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, flo
'y' : ps['y'] } 'y' : ps['y'] }
return coord return coord
@app.post("/setreservoirhead/") @app.post("/setreservoirhead/",response_model=None)
async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet: async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
ps = { 'id' : reservoir, ps = { 'id' : reservoir,
'head' : head } 'head' : head }
return set_reservoir(network, ChangeSet(ps)) return set_reservoir(network, ChangeSet(ps))
@app.post("/setreservoirpattern/") @app.post("/setreservoirpattern/",response_model=None)
async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet: async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
ps = { 'id' : reservoir, ps = { 'id' : reservoir,
'pattern' : pattern } 'pattern' : pattern }
return set_reservoir(network, ChangeSet(ps)) return set_reservoir(network, ChangeSet(ps))
@app.post("/setreservoirx/") @app.post("/setreservoirx/",response_model=None)
async def fastapi_set_reservoir_x(network: str, reservoir: str, x: float) -> ChangeSet: async def fastapi_set_reservoir_x(network: str, reservoir: str, x: float) -> ChangeSet:
ps = { 'id' : reservoir, ps = { 'id' : reservoir,
'x' : x } 'x' : x }
return set_reservoir(network, ChangeSet(ps)) return set_reservoir(network, ChangeSet(ps))
@app.post("/setreservoirx/") @app.post("/setreservoirx/",response_model=None)
async def fastapi_set_reservoir_y(network: str, reservoir: str, y: float) -> ChangeSet: async def fastapi_set_reservoir_y(network: str, reservoir: str, y: float) -> ChangeSet:
ps = { 'id' : reservoir, ps = { 'id' : reservoir,
'y' : y } 'y' : y }
return set_reservoir(network, ChangeSet(ps)) return set_reservoir(network, ChangeSet(ps))
@app.post("/setreservoircoord/") @app.post("/setreservoircoord/",response_model=None)
async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: float) -> ChangeSet: async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
ps = { 'id' : reservoir, ps = { 'id' : reservoir,
'x' : x, 'x' : x,
@@ -548,7 +548,7 @@ async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: flo
async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]: async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]:
return get_reservoir(network, reservoir) return get_reservoir(network, reservoir)
@app.post("/setreservoirproperties/") @app.post("/setreservoirproperties/",response_model=None)
async def fastapi_set_reservoir_properties(network: str, reservoir: str async def fastapi_set_reservoir_properties(network: str, reservoir: str
, req: Request) -> ChangeSet: , req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
@@ -563,7 +563,7 @@ async def fastapi_set_reservoir_properties(network: str, reservoir: str
async def fast_get_tank_schema(network: str) -> dict[str, dict[str, Any]]: async def fast_get_tank_schema(network: str) -> dict[str, dict[str, Any]]:
return get_tank_schema(network) return get_tank_schema(network)
@app.post("/addtank/") @app.post("/addtank/",response_model=None)
async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet: async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'x' : x, 'x' : x,
@@ -577,7 +577,7 @@ async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevatio
} }
return add_tank(network, ChangeSet(ps)) return add_tank(network, ChangeSet(ps))
@app.post("/deletetank/") @app.post("/deletetank/",response_model=None)
async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet: async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
ps = { 'id' : tank } ps = { 'id' : tank }
return delete_tank(network, ChangeSet(ps)) return delete_tank(network, ChangeSet(ps))
@@ -639,67 +639,67 @@ async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float]:
'y' : ps['y'] } 'y' : ps['y'] }
return coord return coord
@app.post("/settankelevation/") @app.post("/settankelevation/",response_model=None)
async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet: async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'elevation' : elevation } 'elevation' : elevation }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankinitlevel/") @app.post("/settankinitlevel/",response_model=None)
async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet: async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'init_level' : init_level } 'init_level' : init_level }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankminlevel/") @app.post("/settankminlevel/",response_model=None)
async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet: async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'min_level' : min_level } 'min_level' : min_level }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankmaxlevel/") @app.post("/settankmaxlevel/",response_model=None)
async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet: async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'max_level' : max_level } 'max_level' : max_level }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("settankdiameter//") @app.post("settankdiameter//",response_model=None)
async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet: async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'diameter' : diameter } 'diameter' : diameter }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankminvol/") @app.post("/settankminvol/",response_model=None)
async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet: async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'min_vol' : min_vol } 'min_vol' : min_vol }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankvolcurve/") @app.post("/settankvolcurve/",response_model=None)
async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet: async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'vol_curve' : vol_curve} 'vol_curve' : vol_curve}
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankoverflow/") @app.post("/settankoverflow/",response_model=None)
async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet: async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'overflow' : overflow } 'overflow' : overflow }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankx/") @app.post("/settankx/",response_model=None)
async def fastapi_set_tank_x(network: str, tank: str, x: float) -> ChangeSet: async def fastapi_set_tank_x(network: str, tank: str, x: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'x' : x } 'x' : x }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settanky/") @app.post("/settanky/",response_model=None)
async def fastapi_set_tank_y(network: str, tank: str, y: float) -> ChangeSet: async def fastapi_set_tank_y(network: str, tank: str, y: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'y' : y } 'y' : y }
return set_tank(network, ChangeSet(ps)) return set_tank(network, ChangeSet(ps))
@app.post("/settankcoord/") @app.post("/settankcoord/",response_model=None)
async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet: async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
ps = { 'id' : tank, ps = { 'id' : tank,
'x' : x, 'x' : x,
@@ -710,7 +710,7 @@ async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) ->
async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]: async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]:
return get_tank(network, tank) return get_tank(network, tank)
@app.post("/settankproperties/") @app.post("/settankproperties/",response_model=None)
async def fastapi_set_tank_properties(network: str, tank: str, req: Request) -> ChangeSet: async def fastapi_set_tank_properties(network: str, tank: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : tank } | props ps = { 'id' : tank } | props
@@ -723,7 +723,7 @@ async def fastapi_set_tank_properties(network: str, tank: str, req: Request) ->
async def fastapi_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]: async def fastapi_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]:
return get_pipe_schema(network) return get_pipe_schema(network)
@app.post("/addpipe/") @app.post("/addpipe/",response_model=None)
async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0, async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0,
diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet: diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
@@ -736,7 +736,7 @@ async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, leng
'status' : status } 'status' : status }
return add_pipe(network, ChangeSet(ps)) return add_pipe(network, ChangeSet(ps))
@app.post("/deletepipe/") @app.post("/deletepipe/",response_model=None)
async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet: async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
ps = {'id' : pipe} ps = {'id' : pipe}
return delete_pipe(network, ChangeSet(ps)) return delete_pipe(network, ChangeSet(ps))
@@ -776,43 +776,43 @@ async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
ps = get_pipe(network, pipe) ps = get_pipe(network, pipe)
return ps['status'] return ps['status']
@app.post("/setpipenode1/") @app.post("/setpipenode1/",response_model=None)
async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet: async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'node1' : node1 } 'node1' : node1 }
return set_pipe(network, ChangeSet(ps)) return set_pipe(network, ChangeSet(ps))
@app.post("/setpipenode2/") @app.post("/setpipenode2/",response_model=None)
async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet: async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'node2' : node2 } 'node2' : node2 }
return set_pipe(network, ChangeSet(ps)) return set_pipe(network, ChangeSet(ps))
@app.post("/setpipelength/") @app.post("/setpipelength/",response_model=None)
async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet: async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'length' : length } 'length' : length }
return set_pipe(network, ChangeSet(ps)) return set_pipe(network, ChangeSet(ps))
@app.post("/setpipediameter/") @app.post("/setpipediameter/",response_model=None)
async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet: async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'diameter' : diameter } 'diameter' : diameter }
return set_pipe(network, ChangeSet(ps)) return set_pipe(network, ChangeSet(ps))
@app.post("/setpiperoughness/") @app.post("/setpiperoughness/",response_model=None)
async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet: async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'roughness' : roughness } 'roughness' : roughness }
return set_pipe(network, ChangeSet(ps)) return set_pipe(network, ChangeSet(ps))
@app.post("/setpipeminorloss/") @app.post("/setpipeminorloss/",response_model=None)
async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet: async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'minor_loss' : minor_loss } 'minor_loss' : minor_loss }
return set_pipe(network, ChangeSet(ps)) return set_pipe(network, ChangeSet(ps))
@app.post("/setpipestatus/") @app.post("/setpipestatus/",response_model=None)
async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> ChangeSet: async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> ChangeSet:
ps = { 'id' : pipe, ps = { 'id' : pipe,
'status' : status } 'status' : status }
@@ -828,7 +828,7 @@ async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> Chang
async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]: async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]:
return get_pipe(network, pipe) return get_pipe(network, pipe)
@app.post("/setpipeproperties/") @app.post("/setpipeproperties/",response_model=None)
async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) -> ChangeSet: async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : pipe } | props ps = { 'id' : pipe } | props
@@ -842,7 +842,7 @@ async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) ->
async def fastapi_get_pump_schema(network: str) -> dict[str, dict[str, Any]]: async def fastapi_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
return get_pump_schema(network) return get_pump_schema(network)
@app.post("/addpump/") @app.post("/addpump/",response_model=None)
async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, power: float = 0.0) -> ChangeSet: async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, power: float = 0.0) -> ChangeSet:
ps = { 'id' : pump, ps = { 'id' : pump,
'node1' : node1, 'node1' : node1,
@@ -851,7 +851,7 @@ async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, powe
} }
return add_pump(network, ChangeSet(ps)) return add_pump(network, ChangeSet(ps))
@app.post("/deletepump/") @app.post("/deletepump/",response_model=None)
async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet: async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
ps = { 'id' : pump } ps = { 'id' : pump }
return delete_pump(network, ChangeSet(ps)) return delete_pump(network, ChangeSet(ps))
@@ -866,13 +866,13 @@ async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
ps = get_pump(network, pump) ps = get_pump(network, pump)
return ps['node2'] return ps['node2']
@app.post("/setpumpnode1/") @app.post("/setpumpnode1/",response_model=None)
async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet: async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
ps = { 'id' : pump, ps = { 'id' : pump,
'node1' : node1 } 'node1' : node1 }
return set_pump(network, ChangeSet(ps)) return set_pump(network, ChangeSet(ps))
@app.post("/setpumpnode2/") @app.post("/setpumpnode2/",response_model=None)
async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet: async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
ps = { 'id' : pump, ps = { 'id' : pump,
'node2' : node2 } 'node2' : node2 }
@@ -882,7 +882,7 @@ async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeS
async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]: async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]:
return get_pump(network, pump) return get_pump(network, pump)
@app.post("/setpumpproperties/") @app.post("/setpumpproperties/",response_model=None)
async def fastapi_set_pump_properties(network: str, pump: str, req: Request) -> ChangeSet: async def fastapi_set_pump_properties(network: str, pump: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : pump } | props ps = { 'id' : pump } | props
@@ -896,7 +896,7 @@ async def fastapi_set_pump_properties(network: str, pump: str, req: Request) ->
async def fastapi_get_valve_schema(network: str) -> dict[str, dict[str, Any]]: async def fastapi_get_valve_schema(network: str) -> dict[str, dict[str, Any]]:
return get_valve_schema(network) return get_valve_schema(network)
@app.post("/addvalve/") @app.post("/addvalve/",response_model=None)
async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, diameter: float = 0, v_type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet: async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, diameter: float = 0, v_type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
ps = { 'id' : valve, ps = { 'id' : valve,
'node1' : node1, 'node1' : node1,
@@ -908,7 +908,7 @@ async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, di
return add_valve(network, ChangeSet(ps)) return add_valve(network, ChangeSet(ps))
@app.post("/deletevalve/") @app.post("/deletevalve/",response_model=None)
async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet: async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
ps = { 'id' : valve } ps = { 'id' : valve }
return delete_valve(network, ChangeSet(ps)) return delete_valve(network, ChangeSet(ps))
@@ -943,31 +943,31 @@ async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None
ps = get_valve(network, valve) ps = get_valve(network, valve)
return ps['minor_loss'] return ps['minor_loss']
@app.post("/setvalvenode1/") @app.post("/setvalvenode1/",response_model=None)
async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet: async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
ps = { 'id' : valve, ps = { 'id' : valve,
'node1' : node1 } 'node1' : node1 }
return set_valve(network, ChangeSet(ps)) return set_valve(network, ChangeSet(ps))
@app.post("/setvalvenode2/") @app.post("/setvalvenode2/",response_model=None)
async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet: async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
ps = { 'id' : valve, ps = { 'id' : valve,
'node2' : node2 } 'node2' : node2 }
return set_valve(network, ChangeSet(ps)) return set_valve(network, ChangeSet(ps))
@app.post("/setvalvenodediameter/") @app.post("/setvalvenodediameter/",response_model=None)
async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet: async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
ps = { 'id' : valve, ps = { 'id' : valve,
'diameter' : diameter } 'diameter' : diameter }
return set_valve(network, ChangeSet(ps)) return set_valve(network, ChangeSet(ps))
@app.post("/setvalvetype/") @app.post("/setvalvetype/",response_model=None)
async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet: async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
ps = { 'id' : valve, ps = { 'id' : valve,
'type' : type } 'type' : type }
return set_valve(network, ChangeSet(ps)) return set_valve(network, ChangeSet(ps))
@app.post("/setvalvesetting/") @app.post("/setvalvesetting/",response_model=None)
async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet: async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
ps = { 'id' : valve, ps = { 'id' : valve,
'setting' : setting } 'setting' : setting }
@@ -977,7 +977,7 @@ async def fastapi_set_valve_setting(network: str, valve: str, setting: float) ->
async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]: async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]:
return get_valve(network, valve) return get_valve(network, valve)
@app.post("/setvalveproperties/") @app.post("/setvalveproperties/",response_model=None)
async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -> ChangeSet: async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : valve } | props ps = { 'id' : valve } | props
@@ -985,7 +985,7 @@ async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -
# node & link # node & link
@app.post("/deletenode/") @app.post("/deletenode/",response_model=None)
async def fastapi_delete_node(network: str, node: str) -> ChangeSet: async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
ps = {'id' : node} ps = {'id' : node}
if is_junction(network, node): if is_junction(network, node):
@@ -995,7 +995,7 @@ async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
elif is_tank(network, node): elif is_tank(network, node):
return delete_tank(network, ChangeSet(ps)) return delete_tank(network, ChangeSet(ps))
@app.post("/deletelink/") @app.post("/deletelink/",response_model=None)
async def fastapi_delete_link(network: str, link: str) -> ChangeSet: async def fastapi_delete_link(network: str, link: str) -> ChangeSet:
ps = {'id' : link} ps = {'id' : link}
if is_pipe(network, link): if is_pipe(network, link):
@@ -1030,7 +1030,7 @@ async def fastapi_get_tags(network: str) -> list[dict[str, Any]]:
# example: # example:
# set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' })) # set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' }))
# set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' })) # set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
@app.post('/settag/') @app.post('/settag/',response_model=None)
async def fastapi_set_tag(network: str, req: Request) -> ChangeSet: async def fastapi_set_tag(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_tag(network, ChangeSet(props)) return set_tag(network, ChangeSet(props))
@@ -1047,7 +1047,7 @@ async def fastapi_get_demand_properties(network: str, junction: str) -> dict[str
return get_demand(network, junction) return get_demand(network, junction)
# example: set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]})) # example: set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]}))
@app.post("/setdemandproperties/") @app.post("/setdemandproperties/",response_model=None)
async def fastapi_set_demand_properties(network: str, junction: str, req: Request) -> ChangeSet: async def fastapi_set_demand_properties(network: str, junction: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'junction' : junction } | props ps = { 'junction' : junction } | props
@@ -1065,7 +1065,7 @@ async def fastapi_get_status(network: str, link: str) -> dict[str, Any]:
return get_status(network, link) return get_status(network, link)
# example: set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0})) # example: set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
@app.post("/setstatus/") @app.post("/setstatus/",response_model=None)
async def fastapi_set_status_properties(network: str, link: str, req: Request) -> ChangeSet: async def fastapi_set_status_properties(network: str, link: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'link' : link } | props ps = { 'link' : link } | props
@@ -1078,7 +1078,7 @@ async def fastapi_set_status_properties(network: str, link: str, req: Request) -
async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]: async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]:
return get_pattern_schema(network) return get_pattern_schema(network)
@app.post("/addpattern/") @app.post("/addpattern/",response_model=None)
async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> ChangeSet: async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { ps = {
@@ -1086,7 +1086,7 @@ async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> Chang
} | props } | props
return add_pattern(network, ChangeSet(ps)) return add_pattern(network, ChangeSet(ps))
@app.post("/deletepattern/") @app.post("/deletepattern/",response_model=None)
async def fastapi_delete_pattern(network: str, pattern: str) -> ChangeSet: async def fastapi_delete_pattern(network: str, pattern: str) -> ChangeSet:
ps = { 'id' : pattern } ps = { 'id' : pattern }
return delete_pattern(network, ChangeSet(ps)) return delete_pattern(network, ChangeSet(ps))
@@ -1096,7 +1096,7 @@ async def fastapi_get_pattern_properties(network: str, pattern: str) -> dict[str
return get_pattern(network, pattern) return get_pattern(network, pattern)
# example: set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]})) # example: set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
@app.post("/setpatternproperties/") @app.post("/setpatternproperties/",response_model=None)
async def fastapi_set_pattern_properties(network: str, pattern: str, req: Request) -> ChangeSet: async def fastapi_set_pattern_properties(network: str, pattern: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : pattern } | props ps = { 'id' : pattern } | props
@@ -1109,7 +1109,7 @@ async def fastapi_set_pattern_properties(network: str, pattern: str, req: Reques
async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]: async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
return get_curve_schema(network) return get_curve_schema(network)
@app.post("/addcurve/") @app.post("/addcurve/",response_model=None)
async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet: async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
@@ -1123,7 +1123,7 @@ async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet
return add_curve(network, ChangeSet(ps)) return add_curve(network, ChangeSet(ps))
@app.post("/deletecurve/") @app.post("/deletecurve/",response_model=None)
async def fastapi_delete_curve(network: str, curve: str) -> ChangeSet: async def fastapi_delete_curve(network: str, curve: str) -> ChangeSet:
ps = { 'id' : curve } ps = { 'id' : curve }
return delete_curve(network, ChangeSet(ps)) return delete_curve(network, ChangeSet(ps))
@@ -1133,7 +1133,7 @@ async def fastapi_get_curve_properties(network: str, curve: str) -> dict[str, An
return get_curve(network, curve) return get_curve(network, curve)
# example: set_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]})) # example: set_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
@app.post("/setcurveproperties/") @app.post("/setcurveproperties/",response_model=None)
async def fastapi_set_curve_properties(network: str, curve: str, req: Request) -> ChangeSet: async def fastapi_set_curve_properties(network: str, curve: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
# c_type放到request中 # c_type放到request中
@@ -1153,7 +1153,7 @@ async def fastapi_get_control_properties(network: str) -> dict[str, Any]:
return get_control(network) return get_control(network)
# example: set_control(p, ChangeSet({'control': 'x'})) # example: set_control(p, ChangeSet({'control': 'x'}))
@app.post("/setcontrolproperties/") @app.post("/setcontrolproperties/",response_model=None)
async def fastapi_set_control_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_control_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_control(network, ChangeSet(props)) return set_control(network, ChangeSet(props))
@@ -1170,7 +1170,7 @@ async def fastapi_get_rule_properties(network: str) -> dict[str, Any]:
return get_rule(network) return get_rule(network)
# example: set_rule(p, ChangeSet({'rule': 'x'})) # example: set_rule(p, ChangeSet({'rule': 'x'}))
@app.post("/setruleproperties/") @app.post("/setruleproperties/",response_model=None)
async def fastapi_set_rule_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_rule_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_rule(network, ChangeSet(props)) return set_rule(network, ChangeSet(props))
@@ -1187,7 +1187,7 @@ async def fastapi_get_energy_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_energy_properties(network: str) -> dict[str, Any]: async def fastapi_get_energy_properties(network: str) -> dict[str, Any]:
return get_energy(network) return get_energy(network)
@app.post("/setenergyproperties/") @app.post("/setenergyproperties/",response_model=None)
async def fastapi_set_energy_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_energy_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_energy(network, ChangeSet(props)) return set_energy(network, ChangeSet(props))
@@ -1200,7 +1200,7 @@ async def fastapi_get_pump_energy_schema(network: str) -> dict[str, dict[str, An
async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[str, Any]: async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[str, Any]:
return get_pump_energy(network, pump) return get_pump_energy(network, pump)
@app.get("/setpumpenergyproperties//") @app.get("/setpumpenergyproperties//",response_model=None)
async def fastapi_set_pump_energy_properties(network: str, pump: str, req: Request) -> ChangeSet: async def fastapi_set_pump_energy_properties(network: str, pump: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'id' : pump } | props ps = { 'id' : pump } | props
@@ -1218,7 +1218,7 @@ async def fastapi_get_emitter_properties(network: str, junction: str) -> dict[st
return get_emitter(network, junction) return get_emitter(network, junction)
# example: set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0})) # example: set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0}))
@app.post("/setemitterproperties/") @app.post("/setemitterproperties/",response_model=None)
async def fastapi_set_emitter_properties(network: str, junction: str, req: Request) -> ChangeSet: async def fastapi_set_emitter_properties(network: str, junction: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
ps = { 'junction' : junction } | props ps = { 'junction' : junction } | props
@@ -1237,7 +1237,7 @@ async def fastapi_get_quality_properties(network: str, node: str) -> dict[str, A
return get_quality(network, node) return get_quality(network, node)
# example: set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0})) # example: set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0}))
@app.post("/setqualityproperties/") @app.post("/setqualityproperties/",response_model=None)
async def fastapi_set_quality_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_quality_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_quality(network, ChangeSet(props)) return set_quality(network, ChangeSet(props))
@@ -1254,18 +1254,18 @@ async def fastapi_get_source_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_source(network: str, node: str) -> dict[str, Any]: async def fastapi_get_source(network: str, node: str) -> dict[str, Any]:
return get_source(network, node) return get_source(network, node)
@app.post('/setsource/') @app.post('/setsource/',response_model=None)
async def fastapi_set_source(network: str, req: Request) -> ChangeSet: async def fastapi_set_source(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_source(network, ChangeSet(props)) return set_source(network, ChangeSet(props))
# example: add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'})) # example: add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'}))
@app.post('/addsource/') @app.post('/addsource/',response_model=None)
async def fastapi_add_source(network: str, req: Request) -> ChangeSet: async def fastapi_add_source(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_source(network, ChangeSet(props)) return add_source(network, ChangeSet(props))
@app.post('/deletesource/') @app.post('/deletesource/',response_model=None)
async def fastapi_delete_source(network: str, node: str) -> ChangeSet: async def fastapi_delete_source(network: str, node: str) -> ChangeSet:
props = { 'node': node } props = { 'node': node }
return delete_source(network, ChangeSet(props)) return delete_source(network, ChangeSet(props))
@@ -1282,7 +1282,7 @@ async def fastapi_get_reaction_schema(network: str) -> dict[str, dict[str, Any]]
async def fastapi_get_reaction(network: str) -> dict[str, Any]: async def fastapi_get_reaction(network: str) -> dict[str, Any]:
return get_reaction(network) return get_reaction(network)
@app.post('/setreaction/') @app.post('/setreaction/',response_model=None)
# set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' })) # set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' }))
async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet: async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
@@ -1296,7 +1296,7 @@ async def fastapi_get_pipe_reaction_schema(network: str) -> dict[str, dict[str,
async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]: async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]:
return get_pipe_reaction(network, pipe) return get_pipe_reaction(network, pipe)
@app.post('/setpipereaction/') @app.post('/setpipereaction/',response_model=None)
async def fastapi_set_pipe_reaction(network: str, req: Request) -> ChangeSet: async def fastapi_set_pipe_reaction(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_pipe_reaction(network, ChangeSet(props)) return set_pipe_reaction(network, ChangeSet(props))
@@ -1309,7 +1309,7 @@ async def fastapi_get_tank_reaction_schema(network: str) -> dict[str, dict[str,
async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]: async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]:
return get_tank_reaction(network, tank) return get_tank_reaction(network, tank)
@app.post('/settankreaction/') @app.post('/settankreaction/',response_model=None)
async def fastapi_set_tank_reaction(network: str, req: Request) -> ChangeSet: async def fastapi_set_tank_reaction(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_tank_reaction(network, ChangeSet(props)) return set_tank_reaction(network, ChangeSet(props))
@@ -1326,18 +1326,18 @@ async def fastapi_get_mixing_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]: async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]:
return get_mixing(network, tank) return get_mixing(network, tank)
@app.post('/setmixing/') @app.post('/setmixing/',response_model=None)
async def fastapi_set_mixing(network: str, req: Request) -> ChangeSet: async def fastapi_set_mixing(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return api.set_mixing(network, ChangeSet(props)) return api.set_mixing(network, ChangeSet(props))
# example: add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0})) # example: add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0}))
@app.post('/addmixing/') @app.post('/addmixing/',response_model=None)
async def fastapi_add_mixing(network: str, req: Request) -> ChangeSet: async def fastapi_add_mixing(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_mixing(network, ChangeSet(props)) return add_mixing(network, ChangeSet(props))
@app.post('/deletemixing/') @app.post('/deletemixing/',response_model=None)
async def fastapi_delete_mixing(network: str, req: Request) -> ChangeSet: async def fastapi_delete_mixing(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_mixing(network, ChangeSet(props)) return delete_mixing(network, ChangeSet(props))
@@ -1354,7 +1354,7 @@ async def fastapi_get_time_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_time_properties(network: str) -> dict[str, Any]: async def fastapi_get_time_properties(network: str) -> dict[str, Any]:
return get_time(network) return get_time(network)
@app.post("/settimeproperties/") @app.post("/settimeproperties/",response_model=None)
async def fastapi_set_time_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_time_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_time(network, ChangeSet(props)) return set_time(network, ChangeSet(props))
@@ -1370,7 +1370,7 @@ async def fastapi_get_option_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_option_properties(network: str) -> dict[str, Any]: async def fastapi_get_option_properties(network: str) -> dict[str, Any]:
return get_option_v3(network) return get_option_v3(network)
@app.post("/setoptionproperties/") @app.post("/setoptionproperties/",response_model=None)
async def fastapi_set_option_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_option_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_option_v3(network, ChangeSet(props)) return set_option_v3(network, ChangeSet(props))
@@ -1394,17 +1394,17 @@ async def fastapi_get_vertex_properties(network: str, link: str) -> dict[str, An
return get_vertex(network, link) return get_vertex(network, link)
# set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]})) # set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
@app.post('/setvertexproperties/') @app.post('/setvertexproperties/',response_model=None)
async def fastapi_set_vertex_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_vertex_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_vertex(network, ChangeSet(props)) return set_vertex(network, ChangeSet(props))
@app.post('/addvertex/') @app.post('/addvertex/',response_model=None)
async def fastapi_add_vertex(network: str, req: Request) -> ChangeSet: async def fastapi_add_vertex(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_vertex(network, ChangeSet(props)) return add_vertex(network, ChangeSet(props))
@app.post('/deletevertex/') @app.post('/deletevertex/',response_model=None)
async def fastapi_delete_vertex(network: str, req: Request) -> ChangeSet: async def fastapi_delete_vertex(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return api.delete_vertex(network, ChangeSet(props)) return api.delete_vertex(network, ChangeSet(props))
@@ -1428,17 +1428,17 @@ async def fastapi_get_label_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_label_properties(network: str, x: float, y: float) -> dict[str, Any]: async def fastapi_get_label_properties(network: str, x: float, y: float) -> dict[str, Any]:
return get_label(network, x, y) return get_label(network, x, y)
@app.post('/setlabelproperties/') @app.post('/setlabelproperties/',response_model=None)
async def fastapi_set_label_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_label_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_label(network, ChangeSet(props)) return set_label(network, ChangeSet(props))
@app.post('/addlabel/') @app.post('/addlabel/',response_model=None)
async def fastapi_add_label(network: str, req: Request) -> ChangeSet: async def fastapi_add_label(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_label(network, ChangeSet(props)) return add_label(network, ChangeSet(props))
@app.post('/deletelabel/') @app.post('/deletelabel/',response_model=None)
async def fastapi_delete_label(network: str, req: Request) -> ChangeSet: async def fastapi_delete_label(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_label(network, ChangeSet(props)) return delete_label(network, ChangeSet(props))
@@ -1455,7 +1455,7 @@ async def fastapi_get_backdrop_schema(network: str) -> dict[str, dict[str, Any]]
async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]: async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]:
return get_backdrop(network) return get_backdrop(network)
@app.post('/setbackdropproperties/') @app.post('/setbackdropproperties/',response_model=None)
async def fastapi_set_backdrop_properties(network: str, req: Request) -> ChangeSet: async def fastapi_set_backdrop_properties(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_backdrop(network, ChangeSet(props)) return set_backdrop(network, ChangeSet(props))
@@ -1471,22 +1471,22 @@ async def fastapi_get_scada_device_schema(network: str) -> dict[str, dict[str, A
async def fastapi_get_scada_device(network: str, id: str) -> dict[str, Any]: async def fastapi_get_scada_device(network: str, id: str) -> dict[str, Any]:
return get_scada_device(network, id) return get_scada_device(network, id)
@app.post('/setscadadevice/') @app.post('/setscadadevice/',response_model=None)
async def fastapi_set_scada_device(network: str, req: Request) -> ChangeSet: async def fastapi_set_scada_device(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_scada_device(network, ChangeSet(props)) return set_scada_device(network, ChangeSet(props))
@app.post('/addscadadevice/') @app.post('/addscadadevice/',response_model=None)
async def fastapi_add_scada_device(network: str, req: Request) -> ChangeSet: async def fastapi_add_scada_device(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_scada_device(network, ChangeSet(props)) return add_scada_device(network, ChangeSet(props))
@app.post('/deletescadadevice/') @app.post('/deletescadadevice/',response_model=None)
async def fastapi_delete_scada_device(network: str, req: Request) -> ChangeSet: async def fastapi_delete_scada_device(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_scada_device(network, ChangeSet(props)) return delete_scada_device(network, ChangeSet(props))
@app.post('/cleanscadadevice/') @app.post('/cleanscadadevice/',response_model=None)
async def fastapi_clean_scada_device(network: str) -> ChangeSet: async def fastapi_clean_scada_device(network: str) -> ChangeSet:
return clean_scada_device(network) return clean_scada_device(network)
@@ -1512,24 +1512,24 @@ async def fastapi_get_scada_device_data(network: str, id: str) -> dict[str, Any]
# example: set_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]})) # example: set_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]}))
# time format must be 'YYYY-MM-DD HH:MM:SS' # time format must be 'YYYY-MM-DD HH:MM:SS'
@app.post('/setscadadevicedata/') @app.post('/setscadadevicedata/',response_model=None)
async def fastapi_set_scada_device_data(network: str, req: Request) -> ChangeSet: async def fastapi_set_scada_device_data(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_scada_device_data(network, ChangeSet(props)) return set_scada_device_data(network, ChangeSet(props))
# example: add_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-10 00:02:22', 'value': 100.0})) # example: add_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
@app.post('/addscadadevicedata/') @app.post('/addscadadevicedata/',response_model=None)
async def fastapi_add_scada_device_data(network: str, req: Request) -> ChangeSet: async def fastapi_add_scada_device_data(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_scada_device_data(network, ChangeSet(props)) return add_scada_device_data(network, ChangeSet(props))
# example: delete_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-12 00:02:22'})) # example: delete_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-12 00:02:22'}))
@app.post('/deletescadadevicedata/') @app.post('/deletescadadevicedata/',response_model=None)
async def fastapi_delete_scada_device_data(network: str, req: Request) -> ChangeSet: async def fastapi_delete_scada_device_data(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_scada_device_data(network, ChangeSet(props)) return delete_scada_device_data(network, ChangeSet(props))
@app.post('/cleanscadadevicedata/') @app.post('/cleanscadadevicedata/',response_model=None)
async def fastapi_clean_scada_device_data(network: str) -> ChangeSet: async def fastapi_clean_scada_device_data(network: str) -> ChangeSet:
return clean_scada_device_data(network) return clean_scada_device_data(network)
@@ -1549,22 +1549,22 @@ async def fastapi_get_scada_elements(network: str) -> list[str]:
async def fastapi_get_scada_element(network: str, id: str) -> dict[str, Any]: async def fastapi_get_scada_element(network: str, id: str) -> dict[str, Any]:
return get_scada_element(network, id) return get_scada_element(network, id)
@app.post('/setscadaelement/') @app.post('/setscadaelement/',response_model=None)
async def fastapi_set_scada_element(network: str, req: Request) -> ChangeSet: async def fastapi_set_scada_element(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_scada_element(network, ChangeSet(props)) return set_scada_element(network, ChangeSet(props))
@app.post('/addscadaelement/') @app.post('/addscadaelement/',response_model=None)
async def fastapi_add_scada_element(network: str, req: Request) -> ChangeSet: async def fastapi_add_scada_element(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_scada_element(network, ChangeSet(props)) return add_scada_element(network, ChangeSet(props))
@app.post('/deletescadaelement/') @app.post('/deletescadaelement/',response_model=None)
async def fastapi_delete_scada_element(network: str, req: Request) -> ChangeSet: async def fastapi_delete_scada_element(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_scada_element(network, ChangeSet(props)) return delete_scada_element(network, ChangeSet(props))
@app.post('/cleanscadaelement/') @app.post('/cleanscadaelement/',response_model=None)
async def fastapi_clean_scada_element(network: str) -> ChangeSet: async def fastapi_clean_scada_element(network: str) -> ChangeSet:
return clean_scada_element(network) return clean_scada_element(network)
@@ -1579,18 +1579,18 @@ async def fastapi_get_region_schema(network: str) -> dict[str, dict[str, Any]]:
async def fastapi_get_region(network: str, id: str) -> dict[str, Any]: async def fastapi_get_region(network: str, id: str) -> dict[str, Any]:
return get_region(network, id) return get_region(network, id)
@app.post('/setregion/') @app.post('/setregion/',response_model=None)
async def fastapi_set_region(network : str, req: Request) -> ChangeSet: async def fastapi_set_region(network : str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_region(network, ChangeSet(props)) return set_region(network, ChangeSet(props))
# example: add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]})) # example: add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
@app.post('/addregion/') @app.post('/addregion/',response_model=None)
async def fastapi_add_region(network: str, req: Request) -> ChangeSet: async def fastapi_add_region(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_region(network, ChangeSet(props)) return add_region(network, ChangeSet(props))
@app.post('/deleteregion/') @app.post('/deleteregion/',response_model=None)
async def fastapi_delete_region(network: str, req: Request) -> ChangeSet: async def fastapi_delete_region(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_region(network, ChangeSet(props)) return delete_region(network, ChangeSet(props))
@@ -1629,12 +1629,12 @@ async def fastapi_get_district_metering_area_schema(network: str) -> dict[str, d
async def fastapi_get_district_metering_area(network: str, id: str) -> dict[str, Any]: async def fastapi_get_district_metering_area(network: str, id: str) -> dict[str, Any]:
return get_district_metering_area(network, id) return get_district_metering_area(network, id)
@app.post('/setdistrictmeteringarea/') @app.post('/setdistrictmeteringarea/',response_model=None)
async def fastapi_set_district_metering_area(network: str, req: Request) -> ChangeSet: async def fastapi_set_district_metering_area(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_district_metering_area(network, ChangeSet(props)) return set_district_metering_area(network, ChangeSet(props))
@app.post('/adddistrictmeteringarea/') @app.post('/adddistrictmeteringarea/',response_model=None)
async def fastapi_add_district_metering_area(network: str, req: Request) -> ChangeSet: async def fastapi_add_district_metering_area(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
@@ -1648,7 +1648,7 @@ async def fastapi_add_district_metering_area(network: str, req: Request) -> Chan
return add_district_metering_area(network, ChangeSet(props)) return add_district_metering_area(network, ChangeSet(props))
@app.post('/deletedistrictmeteringarea/') @app.post('/deletedistrictmeteringarea/',response_model=None)
async def fastapi_delete_district_metering_area(network: str, req: Request) -> ChangeSet: async def fastapi_delete_district_metering_area(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_district_metering_area(network, ChangeSet(props)) return delete_district_metering_area(network, ChangeSet(props))
@@ -1661,11 +1661,11 @@ async def fastapi_get_all_district_metering_area_ids(network: str) -> list[str]:
async def getalldistrictmeteringareas(network: str) -> list[dict[str, Any]]: async def getalldistrictmeteringareas(network: str) -> list[dict[str, Any]]:
return get_all_district_metering_areas(network) return get_all_district_metering_areas(network)
@app.post('/generatedistrictmeteringarea/') @app.post('/generatedistrictmeteringarea/',response_model=None)
async def fastapi_generate_district_metering_area(network: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet: async def fastapi_generate_district_metering_area(network: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
return generate_district_metering_area(network, part_count, part_type, inflate_delta) return generate_district_metering_area(network, part_count, part_type, inflate_delta)
@app.post('/generatesubdistrictmeteringarea/') @app.post('/generatesubdistrictmeteringarea/',response_model=None)
async def fastapi_generate_sub_district_metering_area(network: str, dma: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet: async def fastapi_generate_sub_district_metering_area(network: str, dma: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
print(network) print(network)
print(dma) print(dma)
@@ -1689,17 +1689,17 @@ async def fastapi_get_service_area_schema(network: str) -> dict[str, dict[str, A
async def fastapi_get_service_area(network: str, id: str) -> dict[str, Any]: async def fastapi_get_service_area(network: str, id: str) -> dict[str, Any]:
return get_service_area(network, id) return get_service_area(network, id)
@app.post('/setservicearea/') @app.post('/setservicearea/',response_model=None)
async def fastapi_set_service_area(network: str, req: Request) -> ChangeSet: async def fastapi_set_service_area(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_service_area(network, ChangeSet(props)) return set_service_area(network, ChangeSet(props))
@app.post('/addservicearea/') @app.post('/addservicearea/',response_model=None)
async def fastapi_add_service_area(network: str, req: Request) -> ChangeSet: async def fastapi_add_service_area(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_service_area(network, ChangeSet(props)) return add_service_area(network, ChangeSet(props))
@app.post('/deleteservicearea/') @app.post('/deleteservicearea/',response_model=None)
async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet: async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_service_area(network, ChangeSet(props)) return delete_service_area(network, ChangeSet(props))
@@ -1708,7 +1708,7 @@ async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet:
async def fastapi_get_all_service_areas(network: str) -> list[dict[str, Any]]: async def fastapi_get_all_service_areas(network: str) -> list[dict[str, Any]]:
return get_all_service_areas(network) return get_all_service_areas(network)
@app.post('/generateservicearea/') @app.post('/generateservicearea/',response_model=None)
async def fastapi_generate_service_area(network: str, inflate_delta: float) -> ChangeSet: async def fastapi_generate_service_area(network: str, inflate_delta: float) -> ChangeSet:
return generate_service_area(network, inflate_delta) return generate_service_area(network, inflate_delta)
@@ -1728,17 +1728,17 @@ async def fastapi_get_virtual_district_schema(network: str) -> dict[str, dict[st
async def fastapi_get_virtual_district(network: str, id: str) -> dict[str, Any]: async def fastapi_get_virtual_district(network: str, id: str) -> dict[str, Any]:
return get_virtual_district(network, id) return get_virtual_district(network, id)
@app.post('/setvirtualdistrict/') @app.post('/setvirtualdistrict/',response_model=None)
async def fastapi_set_virtual_district(network: str, req: Request) -> ChangeSet: async def fastapi_set_virtual_district(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return set_virtual_district(network, ChangeSet(props)) return set_virtual_district(network, ChangeSet(props))
@app.post('/addvirtualdistrict/') @app.post('/addvirtualdistrict/',response_model=None)
async def fastapi_add_virtual_district(network: str, req: Request) -> ChangeSet: async def fastapi_add_virtual_district(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return add_virtual_district(network, ChangeSet(props)) return add_virtual_district(network, ChangeSet(props))
@app.post('/deletevirtualdistrict/') @app.post('/deletevirtualdistrict/',response_model=None)
async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeSet: async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return delete_virtual_district(network, ChangeSet(props)) return delete_virtual_district(network, ChangeSet(props))
@@ -1747,7 +1747,7 @@ async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeS
async def fastapi_get_all_virtual_district(network: str) -> list[dict[str, Any]]: async def fastapi_get_all_virtual_district(network: str) -> list[dict[str, Any]]:
return get_all_virtual_districts(network) return get_all_virtual_districts(network)
@app.post('/generatevirtualdistrict/') @app.post('/generatevirtualdistrict/',response_model=None)
async def fastapi_generate_virtual_district(network: str, inflate_delta: float, req: Request) -> ChangeSet: async def fastapi_generate_virtual_district(network: str, inflate_delta: float, req: Request) -> ChangeSet:
props = await req.json() props = await req.json()
return generate_virtual_district(network, props['centers'], inflate_delta) return generate_virtual_district(network, props['centers'], inflate_delta)
@@ -1774,13 +1774,12 @@ async def fastapi_calculate_demand_to_network(network: str, demand: float) -> di
return calculate_demand_to_network(network, demand) return calculate_demand_to_network(network, demand)
# inp file # inp file
@app.post("/uploadinp/", status_code=status.HTTP_200_OK) @app.post("/uploadinp/", status_code=status.HTTP_200_OK)
async def upload_inp(file: bytes = File(), name: str = None): async def upload_inp(afile: bytes, name: str ):
filePath = inpDir + str(name) filePath = inpDir + str(name)
f = open(filePath, 'wb') f = open(filePath, 'wb')
f.write(file) f.write(afile)
f.close() f.close()
return True return True

3
startpg.bat Normal file
View File

@@ -0,0 +1,3 @@
d:
cd "d:\postgresql14\bin"
pg_ctl -D ../data -l logfile start

4
startserver.bat
View File

@@ -1 +1,3 @@
uvicorn main:app --host 0.0.0.0 --port 80 --reload f:
cd "f:\DEV\GitHub\TJWaterServer"
uvicorn main:app --host 0.0.0.0 --port 8000 --reload