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

修复类型错误

Browse Source
This commit is contained in:
Jiang
2026-01-22 18:16:32 +08:00
parent d21966e985
commit 7640d96f86
22 changed files with 221 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
app/api/v1/endpoints/components/controls.py
View File

@@ -13,7 +13,7 @@ async def fastapi_get_control_properties(network: str) -> dict[str, Any]:
return get_control(network)
@router.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()
return set_control(network, ChangeSet(props))
@@ -26,6 +26,6 @@ async def fastapi_get_rule_properties(network: str) -> dict[str, Any]:
return get_rule(network)
@router.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()
return set_rule(network, ChangeSet(props))

6
app/api/v1/endpoints/components/curves.py
View File

@@ -9,7 +9,7 @@ async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
return get_curve_schema(network)
@router.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()
ps = {
"id": curve,
@@ -17,7 +17,7 @@ async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet
return add_curve(network, ChangeSet(ps))
@router.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}
return delete_curve(network, ChangeSet(ps))
@@ -28,7 +28,7 @@ async def fastapi_get_curve_properties(network: str, curve: str) -> dict[str, An
@router.post("/setcurveproperties/", response_model=None)
async def fastapi_set_curve_properties(
network: str, curve: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": curve} | props
return set_curve(network, ChangeSet(ps))

8
app/api/v1/endpoints/components/options.py
View File

@@ -13,7 +13,7 @@ async def fastapi_get_time_properties(network: str) -> dict[str, Any]:
return get_time(network)
@router.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()
return set_time(network, ChangeSet(props))
@@ -26,7 +26,7 @@ async def fastapi_get_energy_properties(network: str) -> dict[str, Any]:
return get_energy(network)
@router.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()
return set_energy(network, ChangeSet(props))
@@ -41,7 +41,7 @@ async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[st
@router.get("/setpumpenergyproperties//", response_model=None)
async def fastapi_set_pump_energy_properties(
network: str, pump: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": pump} | props
return set_pump_energy(network, ChangeSet(ps))
@@ -55,6 +55,6 @@ async def fastapi_get_option_properties(network: str) -> dict[str, Any]:
return get_option_v3(network)
@router.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()
return set_option_v3(network, ChangeSet(props))

6
app/api/v1/endpoints/components/patterns.py
View File

@@ -9,7 +9,7 @@ async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]:
return get_pattern_schema(network)
@router.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()
ps = {
"id": pattern,
@@ -17,7 +17,7 @@ async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> Chang
return add_pattern(network, ChangeSet(ps))
@router.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}
return delete_pattern(network, ChangeSet(ps))
@@ -28,7 +28,7 @@ async def fastapi_get_pattern_properties(network: str, pattern: str) -> dict[str
@router.post("/setpatternproperties/", response_model=None)
async def fastapi_set_pattern_properties(
network: str, pattern: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": pattern} | props
return set_pattern(network, ChangeSet(ps))

22
app/api/v1/endpoints/components/quality.py
View File

@@ -13,7 +13,7 @@ async def fastapi_get_quality_properties(network: str, node: str) -> dict[str, A
return get_quality(network, node)
@router.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()
return set_quality(network, ChangeSet(props))
@@ -28,7 +28,7 @@ async def fastapi_get_emitter_properties(network: str, junction: str) -> dict[st
@router.post("/setemitterproperties/", response_model=None)
async def fastapi_set_emitter_properties(
network: str, junction: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"junction": junction} | props
return set_emitter(network, ChangeSet(ps))
@@ -42,17 +42,17 @@ async def fastapi_get_source(network: str, node: str) -> dict[str, Any]:
return get_source(network, node)
@router.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()
return set_source(network, ChangeSet(props))
@router.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()
return add_source(network, ChangeSet(props))
@router.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}
return delete_source(network, ChangeSet(props))
@@ -65,7 +65,7 @@ async def fastapi_get_reaction(network: str) -> dict[str, Any]:
return get_reaction(network)
@router.post("/setreaction/", response_model=None)
async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet:
async def fastapi_set_reaction(network: str, req: Request) -> "ChangeSet":
props = await req.json()
return set_reaction(network, ChangeSet(props))
@@ -78,7 +78,7 @@ async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]:
return get_pipe_reaction(network, pipe)
@router.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()
return set_pipe_reaction(network, ChangeSet(props))
@@ -91,7 +91,7 @@ async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]:
return get_tank_reaction(network, tank)
@router.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()
return set_tank_reaction(network, ChangeSet(props))
@@ -104,16 +104,16 @@ async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]:
return get_mixing(network, tank)
@router.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()
return api.set_mixing(network, ChangeSet(props))
@router.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()
return add_mixing(network, ChangeSet(props))
@router.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()
return delete_mixing(network, ChangeSet(props))

14
app/api/v1/endpoints/components/visuals.py
View File

@@ -15,17 +15,17 @@ async def fastapi_get_vertex_properties(network: str, link: str) -> dict[str, An
return get_vertex(network, link)
@router.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()
return set_vertex(network, ChangeSet(props))
@router.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()
return add_vertex(network, ChangeSet(props))
@router.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()
return delete_vertex(network, ChangeSet(props))
@@ -48,17 +48,17 @@ async def fastapi_get_label_properties(
return get_label(network, x, y)
@router.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()
return set_label(network, ChangeSet(props))
@router.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()
return add_label(network, ChangeSet(props))
@router.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()
return delete_label(network, ChangeSet(props))
@@ -71,6 +71,6 @@ async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]:
return get_backdrop(network)
@router.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()
return set_backdrop(network, ChangeSet(props))

2
app/api/v1/endpoints/extension.py
View File

@@ -23,7 +23,7 @@ async def get_extension_data_endpoint(network: str, key: str) -> str | None:
return get_extension_data(network, key)
@router.post("/setextensiondata", response_model=None)
async def set_extension_data_endpoint(network: str, req: Request) -> ChangeSet:
async def set_extension_data_endpoint(network: str, req: Request) -> "ChangeSet":
props = await req.json()
print(props)
cs = set_extension_data(network, ChangeSet(props))

2
app/api/v1/endpoints/network/demands.py
View File

@@ -22,7 +22,7 @@ async def fastapi_get_demand_properties(network: str, junction: str) -> dict[str
@router.post("/setdemandproperties/", response_model=None)
async def fastapi_set_demand_properties(
network: str, junction: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"junction": junction} | props
return set_demand(network, ChangeSet(ps))

8
app/api/v1/endpoints/network/general.py
View File

@@ -111,7 +111,7 @@ async def fast_get_title(network: str) -> dict[str, Any]:
return get_title(network)
@router.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()
return set_title(network, ChangeSet(props))
@@ -130,7 +130,7 @@ async def fastapi_get_status(network: str, link: str) -> dict[str, Any]:
@router.post("/setstatus/", response_model=None)
async def fastapi_set_status_properties(
network: str, link: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"link": link} | props
return set_status(network, ChangeSet(ps))
@@ -140,7 +140,7 @@ async def fastapi_set_status_properties(
############################################################
@router.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}
if is_junction(network, node):
return delete_junction(network, ChangeSet(ps))
@@ -151,7 +151,7 @@ async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
return ChangeSet() # Should probably raise error or return empty
@router.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}
if is_pipe(network, link):
return delete_pipe(network, ChangeSet(ps))

4
app/api/v1/endpoints/network/geometry.py
View File

@@ -21,7 +21,7 @@ async def fastapi_get_coord(network: str, node: str) -> dict[str, Any]:
# example: set_coord(p, ChangeSet({'node': 'j1', 'x': 1.0, 'y': 2.0}))
@router.post("/setcoord/", response_model=None)
async def fastapi_set_coord(network: str, req: Request) -> ChangeSet:
async def fastapi_set_coord(network: str, req: Request) -> "ChangeSet":
props = await req.json()
return set_coord(network, ChangeSet(props))
@@ -76,5 +76,5 @@ async def fastapi_get_all_coords(network: str) -> list[Any]:
@router.get("/projectcoordinates/")
async def fastapi_project_coordinates(
network: str, from_epsg: int, to_epsg: int
) -> ChangeSet:
) -> "ChangeSet":
return project_coordinates(network, from_epsg, to_epsg)

18
app/api/v1/endpoints/network/junctions.py
View File

@@ -11,12 +11,12 @@ async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]:
@router.post("/addjunction/", response_model=None)
async def fastapi_add_junction(
network: str, junction: str, x: float, y: float, z: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": junction, "x": x, "y": y, "elevation": z}
return add_junction(network, ChangeSet(ps))
@router.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}
return delete_junction(network, ChangeSet(ps))
@@ -54,38 +54,38 @@ async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
@router.post("/setjunctionelevation/", response_model=None)
async def fastapi_set_junction_elevation(
network: str, junction: str, elevation: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": junction, "elevation": elevation}
return set_junction(network, ChangeSet(ps))
@router.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, "x": x}
return set_junction(network, ChangeSet(ps))
@router.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, "y": y}
return set_junction(network, ChangeSet(ps))
@router.post("/setjunctioncoord/", response_model=None)
async def fastapi_set_junction_coord(
network: str, junction: str, x: float, y: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": junction, "x": x, "y": y}
return set_junction(network, ChangeSet(ps))
@router.post("/setjunctiondemand/", response_model=None)
async def fastapi_set_junction_demand(
network: str, junction: str, demand: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": junction, "demand": demand}
return set_junction(network, ChangeSet(ps))
@router.post("/setjunctionpattern/", response_model=None)
async def fastapi_set_junction_pattern(
network: str, junction: str, pattern: str
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": junction, "pattern": pattern}
return set_junction(network, ChangeSet(ps))
@@ -105,7 +105,7 @@ async def fastapi_get_all_junction_properties(network: str) -> list[dict[str, An
@router.post("/setjunctionproperties/", response_model=None)
async def fastapi_set_junction_properties(
network: str, junction: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": junction} | props
return set_junction(network, ChangeSet(ps))

20
app/api/v1/endpoints/network/pipes.py
View File

@@ -19,7 +19,7 @@ async def fastapi_add_pipe(
roughness: float = 0,
minor_loss: float = 0,
status: str = PIPE_STATUS_OPEN,
) -> ChangeSet:
) -> "ChangeSet":
ps = {
"id": pipe,
"node1": node1,
@@ -33,7 +33,7 @@ async def fastapi_add_pipe(
return add_pipe(network, ChangeSet(ps))
@router.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}
return delete_pipe(network, ChangeSet(ps))
@@ -73,43 +73,43 @@ async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
return ps["status"]
@router.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, "node1": node1}
return set_pipe(network, ChangeSet(ps))
@router.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, "node2": node2}
return set_pipe(network, ChangeSet(ps))
@router.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, "length": length}
return set_pipe(network, ChangeSet(ps))
@router.post("/setpipediameter/", response_model=None)
async def fastapi_set_pipe_diameter(
network: str, pipe: str, diameter: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": pipe, "diameter": diameter}
return set_pipe(network, ChangeSet(ps))
@router.post("/setpiperoughness/", response_model=None)
async def fastapi_set_pipe_roughness(
network: str, pipe: str, roughness: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": pipe, "roughness": roughness}
return set_pipe(network, ChangeSet(ps))
@router.post("/setpipeminorloss/", response_model=None)
async def fastapi_set_pipe_minor_loss(
network: str, pipe: str, minor_loss: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": pipe, "minor_loss": minor_loss}
return set_pipe(network, ChangeSet(ps))
@router.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, "status": status}
return set_pipe(network, ChangeSet(ps))
@@ -127,7 +127,7 @@ async def fastapi_get_all_pipe_properties(network: str) -> list[dict[str, Any]]:
@router.post("/setpipeproperties/", response_model=None)
async def fastapi_set_pipe_properties(
network: str, pipe: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": pipe} | props
return set_pipe(network, ChangeSet(ps))

10
app/api/v1/endpoints/network/pumps.py
View File

@@ -11,12 +11,12 @@ async def fastapi_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
@router.post("/addpump/", response_model=None)
async def fastapi_add_pump(
network: str, pump: str, node1: str, node2: str, power: float = 0.0
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": pump, "node1": node1, "node2": node2, "power": power}
return add_pump(network, ChangeSet(ps))
@router.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}
return delete_pump(network, ChangeSet(ps))
@@ -31,12 +31,12 @@ async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
return ps["node2"]
@router.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, "node1": node1}
return set_pump(network, ChangeSet(ps))
@router.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, "node2": node2}
return set_pump(network, ChangeSet(ps))
@@ -54,7 +54,7 @@ async def fastapi_get_all_pump_properties(network: str) -> list[dict[str, Any]]:
@router.post("/setpumpproperties/", response_model=None)
async def fastapi_set_pump_properties(
network: str, pump: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": pump} | props
return set_pump(network, ChangeSet(ps))

34
app/api/v1/endpoints/network/regions.py
View File

@@ -21,17 +21,17 @@ async def fastapi_get_region(network: str, id: str) -> dict[str, Any]:
return get_region(network, id)
@router.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()
return set_region(network, ChangeSet(props))
@router.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()
return add_region(network, ChangeSet(props))
@router.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()
return delete_region(network, ChangeSet(props))
@@ -42,7 +42,7 @@ async def fastapi_get_all_regions(network: str) -> list[dict[str, Any]]:
@router.post("/generateregion/", response_model=None)
async def fastapi_generate_region(
network: str, inflate_delta: float
) -> ChangeSet:
) -> "ChangeSet":
return generate_region(network, inflate_delta)
@@ -94,12 +94,12 @@ async def fastapi_get_district_metering_area(network: str, id: str) -> dict[str,
return get_district_metering_area(network, id)
@router.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()
return set_district_metering_area(network, ChangeSet(props))
@router.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()
# boundary should be [(x,y), (x,y)]
boundary = props.get("boundary", [])
@@ -113,7 +113,7 @@ async def fastapi_add_district_metering_area(network: str, req: Request) -> Chan
@router.post("/deletedistrictmeteringarea/", response_model=None)
async def fastapi_delete_district_metering_area(
network: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
return delete_district_metering_area(network, ChangeSet(props))
@@ -128,7 +128,7 @@ async def getalldistrictmeteringareas(network: str) -> list[dict[str, Any]]:
@router.post("/generatedistrictmeteringarea/", response_model=None)
async def fastapi_generate_district_metering_area(
network: str, part_count: int, part_type: int, inflate_delta: float
) -> ChangeSet:
) -> "ChangeSet":
return generate_district_metering_area(
network, part_count, part_type, inflate_delta
)
@@ -136,7 +136,7 @@ async def fastapi_generate_district_metering_area(
@router.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:
) -> "ChangeSet":
return generate_sub_district_metering_area(
network, dma, part_count, part_type, inflate_delta
)
@@ -161,17 +161,17 @@ async def fastapi_get_service_area(network: str, id: str) -> dict[str, Any]:
return get_service_area(network, id)
@router.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()
return set_service_area(network, ChangeSet(props))
@router.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()
return add_service_area(network, ChangeSet(props))
@router.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()
return delete_service_area(network, ChangeSet(props))
@@ -182,7 +182,7 @@ async def fastapi_get_all_service_areas(network: str) -> list[dict[str, Any]]:
@router.post("/generateservicearea/", response_model=None)
async def fastapi_generate_service_area(
network: str, inflate_delta: float
) -> ChangeSet:
) -> "ChangeSet":
return generate_service_area(network, inflate_delta)
@@ -207,17 +207,17 @@ async def fastapi_get_virtual_district(network: str, id: str) -> dict[str, Any]:
return get_virtual_district(network, id)
@router.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()
return set_virtual_district(network, ChangeSet(props))
@router.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()
return add_virtual_district(network, ChangeSet(props))
@router.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()
return delete_virtual_district(network, ChangeSet(props))
@@ -228,7 +228,7 @@ async def fastapi_get_all_virtual_district(network: str) -> list[dict[str, Any]]
@router.post("/generatevirtualdistrict/", response_model=None)
async def fastapi_generate_virtual_district(
network: str, inflate_delta: float, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
return generate_virtual_district(network, props["centers"], inflate_delta)

16
app/api/v1/endpoints/network/reservoirs.py
View File

@@ -11,12 +11,12 @@ async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]:
@router.post("/addreservoir/", response_model=None)
async def fastapi_add_reservoir(
network: str, reservoir: str, x: float, y: float, head: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": reservoir, "x": x, "y": y, "head": head}
return add_reservoir(network, ChangeSet(ps))
@router.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}
return delete_reservoir(network, ChangeSet(ps))
@@ -55,31 +55,31 @@ async def fastapi_get_reservoir_coord(
@router.post("/setreservoirhead/", response_model=None)
async def fastapi_set_reservoir_head(
network: str, reservoir: str, head: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": reservoir, "head": head}
return set_reservoir(network, ChangeSet(ps))
@router.post("/setreservoirpattern/", response_model=None)
async def fastapi_set_reservoir_pattern(
network: str, reservoir: str, pattern: str
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": reservoir, "pattern": pattern}
return set_reservoir(network, ChangeSet(ps))
@router.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, "x": x}
return set_reservoir(network, ChangeSet(ps))
@router.post("/setreservoiry/", 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, "y": y}
return set_reservoir(network, ChangeSet(ps))
@router.post("/setreservoircoord/", response_model=None)
async def fastapi_set_reservoir_coord(
network: str, reservoir: str, x: float, y: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": reservoir, "x": x, "y": y}
return set_reservoir(network, ChangeSet(ps))
@@ -99,7 +99,7 @@ async def fastapi_get_all_reservoir_properties(network: str) -> list[dict[str, A
@router.post("/setreservoirproperties/", response_model=None)
async def fastapi_set_reservoir_properties(
network: str, reservoir: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": reservoir} | props
return set_reservoir(network, ChangeSet(ps))

2
app/api/v1/endpoints/network/tags.py
View File

@@ -22,6 +22,6 @@ async def fastapi_get_tags(network: str) -> list[dict[str, Any]]:
return tags
@router.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()
return set_tag(network, ChangeSet(props))

28
app/api/v1/endpoints/network/tanks.py
View File

@@ -20,7 +20,7 @@ async def fastapi_add_tank(
max_level: float = 0,
diameter: float = 0,
min_vol: float = 0,
) -> ChangeSet:
) -> "ChangeSet":
ps = {
"id": tank,
"x": x,
@@ -35,7 +35,7 @@ async def fastapi_add_tank(
return add_tank(network, ChangeSet(ps))
@router.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}
return delete_tank(network, ChangeSet(ps))
@@ -98,73 +98,73 @@ async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float]:
@router.post("/settankelevation/", response_model=None)
async def fastapi_set_tank_elevation(
network: str, tank: str, elevation: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "elevation": elevation}
return set_tank(network, ChangeSet(ps))
@router.post("/settankinitlevel/", response_model=None)
async def fastapi_set_tank_init_level(
network: str, tank: str, init_level: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "init_level": init_level}
return set_tank(network, ChangeSet(ps))
@router.post("/settankminlevel/", response_model=None)
async def fastapi_set_tank_min_level(
network: str, tank: str, min_level: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "min_level": min_level}
return set_tank(network, ChangeSet(ps))
@router.post("/settankmaxlevel/", response_model=None)
async def fastapi_set_tank_max_level(
network: str, tank: str, max_level: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "max_level": max_level}
return set_tank(network, ChangeSet(ps))
@router.post("settankdiameter//", response_model=None)
async def fastapi_set_tank_diameter(
network: str, tank: str, diameter: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "diameter": diameter}
return set_tank(network, ChangeSet(ps))
@router.post("/settankminvol/", response_model=None)
async def fastapi_set_tank_min_vol(
network: str, tank: str, min_vol: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "min_vol": min_vol}
return set_tank(network, ChangeSet(ps))
@router.post("/settankvolcurve/", response_model=None)
async def fastapi_set_tank_vol_curve(
network: str, tank: str, vol_curve: str
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "vol_curve": vol_curve}
return set_tank(network, ChangeSet(ps))
@router.post("/settankoverflow/", response_model=None)
async def fastapi_set_tank_overflow(
network: str, tank: str, overflow: str
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "overflow": overflow}
return set_tank(network, ChangeSet(ps))
@router.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, "x": x}
return set_tank(network, ChangeSet(ps))
@router.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, "y": y}
return set_tank(network, ChangeSet(ps))
@router.post("/settankcoord/", response_model=None)
async def fastapi_set_tank_coord(
network: str, tank: str, x: float, y: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": tank, "x": x, "y": y}
return set_tank(network, ChangeSet(ps))
@@ -182,7 +182,7 @@ async def fastapi_get_all_tank_properties(network: str) -> list[dict[str, Any]]:
@router.post("/settankproperties/", response_model=None)
async def fastapi_set_tank_properties(
network: str, tank: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": tank} | props
return set_tank(network, ChangeSet(ps))

16
app/api/v1/endpoints/network/valves.py
View File

@@ -18,7 +18,7 @@ async def fastapi_add_valve(
v_type: str = VALVES_TYPE_PRV,
setting: float = 0,
minor_loss: float = 0,
) -> ChangeSet:
) -> "ChangeSet":
ps = {
"id": valve,
"node1": node1,
@@ -32,7 +32,7 @@ async def fastapi_add_valve(
return add_valve(network, ChangeSet(ps))
@router.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}
return delete_valve(network, ChangeSet(ps))
@@ -67,31 +67,31 @@ async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None
return ps["minor_loss"]
@router.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, "node1": node1}
return set_valve(network, ChangeSet(ps))
@router.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, "node2": node2}
return set_valve(network, ChangeSet(ps))
@router.post("/setvalvenodediameter/", response_model=None)
async def fastapi_set_valve_diameter(
network: str, valve: str, diameter: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": valve, "diameter": diameter}
return set_valve(network, ChangeSet(ps))
@router.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, "type": type}
return set_valve(network, ChangeSet(ps))
@router.post("/setvalvesetting/", response_model=None)
async def fastapi_set_valve_setting(
network: str, valve: str, setting: float
) -> ChangeSet:
) -> "ChangeSet":
ps = {"id": valve, "setting": setting}
return set_valve(network, ChangeSet(ps))
@@ -109,7 +109,7 @@ async def fastapi_get_all_valve_properties(network: str) -> list[dict[str, Any]]
@router.post("/setvalveproperties/", response_model=None)
async def fastapi_set_valve_properties(
network: str, valve: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
props = await req.json()
ps = {"id": valve} | props
return set_valve(network, ChangeSet(ps))

4
app/api/v1/endpoints/project.py
View File

@@ -84,7 +84,7 @@ async def import_inp_endpoint(network: str, req: Request):
return ret
@router.get("/exportinp/", response_model=None)
async def export_inp_endpoint(network: str, version: str) -> ChangeSet:
async def export_inp_endpoint(network: str, version: str) -> "ChangeSet":
cs = export_inp(network, version)
op = cs.operations[0]
open_project(network)
@@ -175,7 +175,7 @@ async def fastapi_download_inp(name: str, response: Response):
# DingZQ, 2024-12-28, convert v3 to v2
@router.get("/convertv3tov2/", response_model=None)
async def fastapi_convert_v3_to_v2(req: Request) -> ChangeSet:
async def fastapi_convert_v3_to_v2(req: Request) -> "ChangeSet":
network = "v3Tov2"
jo_root = await req.json()
inp = jo_root["inp"]

24
app/api/v1/endpoints/scada.py
View File

@@ -53,22 +53,22 @@ async def fastapi_get_scada_device(network: str, id: str) -> dict[str, Any]:
return get_scada_device(network, id)
@router.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()
return set_scada_device(network, ChangeSet(props))
@router.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()
return add_scada_device(network, ChangeSet(props))
@router.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()
return delete_scada_device(network, ChangeSet(props))
@router.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)
@router.get("/getallscadadeviceids/")
@@ -95,22 +95,22 @@ async def fastapi_get_scada_device_data(network: str, device_id: str) -> dict[st
return get_scada_device_data(network, device_id)
@router.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()
return set_scada_device_data(network, ChangeSet(props))
@router.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()
return add_scada_device_data(network, ChangeSet(props))
@router.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()
return delete_scada_device_data(network, ChangeSet(props))
@router.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)
@@ -133,22 +133,22 @@ async def fastapi_get_scada_element(network: str, id: str) -> dict[str, Any]:
return get_scada_element(network, id)
@router.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()
return set_scada_element(network, ChangeSet(props))
@router.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()
return add_scada_element(network, ChangeSet(props))
@router.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()
return delete_scada_element(network, ChangeSet(props))
@router.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)

10
app/api/v1/endpoints/snapshots.py
View File

@@ -72,21 +72,21 @@ async def take_snapshot_endpoint(network: str, tag: str) -> None:
return take_snapshot(network, tag)
@router.post("/picksnapshot/", response_model=None)
async def pick_snapshot_endpoint(network: str, tag: str, discard: bool = False) -> ChangeSet:
async def pick_snapshot_endpoint(network: str, tag: str, discard: bool = False) -> "ChangeSet":
return pick_snapshot(network, tag, discard)
@router.post("/pickoperation/", response_model=None)
async def pick_operation_endpoint(
network: str, operation: int, discard: bool = False
) -> ChangeSet:
) -> "ChangeSet":
return pick_operation(network, operation, discard)
@router.get("/syncwithserver/", response_model=None)
async def sync_with_server_endpoint(network: str, operation: int) -> ChangeSet:
async def sync_with_server_endpoint(network: str, operation: int) -> "ChangeSet":
return sync_with_server(network, operation)
@router.post("/batch/", response_model=None)
async def execute_batch_commands_endpoint(network: str, req: Request) -> ChangeSet:
async def execute_batch_commands_endpoint(network: str, req: Request) -> "ChangeSet":
jo_root = await req.json()
cs: ChangeSet = ChangeSet()
cs.operations = jo_root["operations"]
@@ -96,7 +96,7 @@ async def execute_batch_commands_endpoint(network: str, req: Request) -> ChangeS
@router.post("/compressedbatch/", response_model=None)
async def execute_compressed_batch_commands_endpoint(
network: str, req: Request
) -> ChangeSet:
) -> "ChangeSet":
jo_root = await req.json()
cs: ChangeSet = ChangeSet()
cs.operations = jo_root["operations"]