撤销上一个提交

app/api/v1/endpoints/components/controls.py

@@ -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))

app/api/v1/endpoints/components/curves.py

@@ -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) -> "ChangeSe
     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))

app/api/v1/endpoints/components/options.py

@@ -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))

app/api/v1/endpoints/components/patterns.py

@@ -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) -> "Chan
     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))

app/api/v1/endpoints/components/quality.py

@@ -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))

app/api/v1/endpoints/components/visuals.py

@@ -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))

app/api/v1/endpoints/extension.py

@@ -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))

app/api/v1/endpoints/network/demands.py

@@ -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))

app/api/v1/endpoints/network/general.py

@@ -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))

app/api/v1/endpoints/network/geometry.py

@@ -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)

app/api/v1/endpoints/network/junctions.py

@@ -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))

app/api/v1/endpoints/network/pipes.py

@@ -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))

app/api/v1/endpoints/network/pumps.py

@@ -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))

app/api/v1/endpoints/network/regions.py

@@ -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) -> "Cha
 @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)
 

app/api/v1/endpoints/network/reservoirs.py

@@ -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))

app/api/v1/endpoints/network/tags.py

@@ -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))

app/api/v1/endpoints/network/tanks.py

@@ -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))

app/api/v1/endpoints/network/valves.py

@@ -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))

app/api/v1/endpoints/project.py

@@ -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"]

app/api/v1/endpoints/scada.py

@@ -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)
 
 

app/api/v1/endpoints/snapshots.py

@@ -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) -> "Change
 @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"]

app/services/tjnetwork.py

@@ -208,7 +208,7 @@ def dump_inp(name: str, inp: str, version: str = '3') -> None:
 def import_inp(name: str, cs: ChangeSet, version: str = '3') -> bool:
     return api.import_inp(name, cs, version)
 
-def export_inp(name: str, version: str = '3') -> "ChangeSet":
+def export_inp(name: str, version: str = '3') -> ChangeSet:
     return api.export_inp(name, version)
 
 #DingZQ, 2025-02-04, 返回dict[str, Any]
@@ -228,7 +228,7 @@ def dump_output(path: str) -> str:
     return epanet.dump_output(path)
 
 #DingZQ, 2024-12-28, convert inp v3 to v2
-def convert_inp_v3_to_v2(inp: str) -> "ChangeSet":
+def convert_inp_v3_to_v2(inp: str) -> ChangeSet:
     return api.convert_inp_v3_to_v2(inp)    
 
 ############################################################
@@ -238,10 +238,10 @@ def convert_inp_v3_to_v2(inp: str) -> "ChangeSet":
 def get_current_operation(name: str) -> int:
     return api.get_current_operation(name)
 
-def execute_undo(name: str, discard: bool = False) -> "ChangeSet":
+def execute_undo(name: str, discard: bool = False) -> ChangeSet:
     return api.execute_undo(name, discard)
 
-def execute_redo(name: str) -> "ChangeSet":
+def execute_redo(name: str) -> ChangeSet:
     return api.execute_redo(name)
 
 def list_snapshot(name: str) -> list[tuple[int, str]]:
@@ -284,21 +284,21 @@ def get_operation_by_snapshot(name: str, tag: str) -> int | None:
 def get_snapshot_by_operation(name: str, operation: int) -> str | None:
     return api.get_snapshot_by_operation(name, operation)
 
-def pick_snapshot(name: str, tag: str, discard: bool = False) -> "ChangeSet":
+def pick_snapshot(name: str, tag: str, discard: bool = False) -> ChangeSet:
     return api.pick_snapshot(name, tag, discard)
 
-def pick_operation(name: str, operation: int, discard: bool = False) -> "ChangeSet":
+def pick_operation(name: str, operation: int, discard: bool = False) -> ChangeSet:
     return api.pick_operation(name, operation, discard)
 
-def sync_with_server(name: str, operation: int) -> "ChangeSet":
+def sync_with_server(name: str, operation: int) -> ChangeSet:
     return api.sync_with_server(name, operation)
 
 # combine commands as one undo/redo unit
-def execute_batch_command(name: str, cs: ChangeSet) -> "ChangeSet":
+def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
     return api.execute_batch_command(name, cs)
 
 # execute command one by one
-def execute_batch_commands(name: str, cs: ChangeSet) -> "ChangeSet":
+def execute_batch_commands(name: str, cs: ChangeSet) -> ChangeSet:
     return api.execute_batch_commands(name, cs)
 
 def get_restore_operation(name: str) -> int:
@@ -310,7 +310,7 @@ def set_restore_operation(name: str, operation: int) -> None:
 def set_restore_operation_to_current(name: str) -> None:
     return api.set_restore_operation_to_current(name)
 
-def restore(name: str, discard: bool = False) -> "ChangeSet":
+def restore(name: str, discard: bool = False) -> ChangeSet:
     return api.restore(name, discard)
 
 def read(name: str, sql: str):
@@ -339,7 +339,7 @@ def get_all_extension_data(name: str) -> dict[str, Any]:
 def get_extension_data(name: str, key: str) -> str | None:
     return api.get_extension_data(name, key)
 
-def set_extension_data(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_extension_data(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_extension_data(name, cs)
 
 
@@ -454,7 +454,7 @@ def get_title_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_title(name: str) -> dict[str, Any]:
     return api.get_title(name)
 
-def set_title(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_title(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_title(name, cs)
 
 
@@ -472,14 +472,14 @@ def get_junction(name: str, id: str) -> dict[str, Any]:
 def get_all_junctions(name: str) -> list[dict[str, Any]]:
     return api.get_all_junctions(name)
 
-def set_junction(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_junction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_junction(name, cs)
 
 # example: add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
-def add_junction(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_junction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_junction(name, cs)
 
-def delete_junction(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_junction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_junction_cascade(name, cs)
 
 
@@ -497,14 +497,14 @@ def get_reservoir(name: str, id: str) -> dict[str, Any]:
 def get_all_reservoirs(name: str) -> list[dict[str, Any]]:
     return api.get_all_reservoirs(name)
 
-def set_reservoir(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_reservoir(name, cs)
 
 # example: add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
-def add_reservoir(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_reservoir(name, cs)
 
-def delete_reservoir(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_reservoir_cascade(name, cs)
 
 
@@ -522,14 +522,14 @@ def get_tank(name: str, id: str) -> dict[str, Any]:
 def get_all_tanks(name: str) -> list[dict[str, Any]]:
     return api.get_all_tanks(name)
 
-def set_tank(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_tank(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_tank(name, cs)
 
 # example: add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0}))
-def add_tank(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_tank(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_tank(name, cs)
 
-def delete_tank(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_tank(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_tank_cascade(name, cs)
 
 
@@ -547,14 +547,14 @@ def get_pipe(name: str, id: str) -> dict[str, Any]:
 def get_all_pipes(name: str) -> list[dict[str, Any]]:
     return api.get_all_pipes(name)
 
-def set_pipe(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_pipe(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_pipe(name, cs)
 
 # example: add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
-def add_pipe(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_pipe(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_pipe(name, cs)
 
-def delete_pipe(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_pipe(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_pipe_cascade(name, cs)
 
 
@@ -572,14 +572,14 @@ def get_pump(name: str, id: str) -> dict[str, Any]:
 def get_all_pumps(name: str) -> list[dict[str, Any]]:
     return api.get_all_pumps(name)
 
-def set_pump(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_pump(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_pump(name, cs)
 
 # example: add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'power': 0}))
-def add_pump(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_pump(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_pump(name, cs)
 
-def delete_pump(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_pump(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_pump_cascade(name, cs)
 
 
@@ -597,14 +597,14 @@ def get_valve(name: str, id: str) -> dict[str, Any]:
 def get_all_valves(name: str) -> list[dict[str, Any]]:
     return api.get_all_valves(name)
 
-def set_valve(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_valve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_valve(name, cs)
 
 # example: add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
-def add_valve(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_valve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_valve(name, cs)
 
-def delete_valve(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_valve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_valve_cascade(name, cs)
 
 
@@ -624,7 +624,7 @@ def get_tag(name: str, t_type: str, id: str) -> dict[str, Any]:
 # example:
 # 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' }))
-def set_tag(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_tag(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_tag(name, cs)
 
 
@@ -639,7 +639,7 @@ def get_demand(name: str, junction: str) -> dict[str, Any]:
     return api.get_demand(name, junction)
 
 # example: set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]}))
-def set_demand(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_demand(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_demand(name, cs)
 
 
@@ -654,7 +654,7 @@ def get_status(name: str, link: str) -> dict[str, Any]:
     return api.get_status(name, link)
 
 # example: set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
-def set_status(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_status(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_status(name, cs)
 
 
@@ -668,14 +668,14 @@ def get_pattern_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_pattern(name: str, id: str) -> dict[str, Any]:
     return api.get_pattern(name, id)
 
-def set_pattern(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_pattern(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_pattern(name, cs)
 
 # example: add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
-def add_pattern(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_pattern(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_pattern(name, cs)
 
-def delete_pattern(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_pattern(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_pattern_cascade(name, cs)
 
 
@@ -689,14 +689,14 @@ def get_curve_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_curve(name: str, id: str) -> dict[str, Any]:
     return api.get_curve(name, id)
 
-def set_curve(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_curve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_curve(name, cs)
 
 # example: add_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
-def add_curve(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_curve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_curve(name, cs)
 
-def delete_curve(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_curve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_curve_cascade(name, cs)
 
 
@@ -711,7 +711,7 @@ def get_control(name: str) -> dict[str, Any]:
     return api.get_control(name)
 
 # example: set_control(p, ChangeSet({'control': 'x'}))
-def set_control(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_control(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_control(name, cs)
 
 
@@ -726,7 +726,7 @@ def get_rule(name: str) -> dict[str, Any]:
     return api.get_rule(name)
 
 # example: set_rule(p, ChangeSet({'rule': 'x'}))
-def set_rule(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_rule(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_rule(name, cs)
 
 
@@ -740,7 +740,7 @@ def get_energy_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_energy(name: str) -> dict[str, Any]:
     return api.get_energy(name)
 
-def set_energy(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_energy(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_energy(name, cs)
 
 def get_pump_energy_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -749,7 +749,7 @@ def get_pump_energy_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_pump_energy(name: str, pump: str) -> dict[str, Any]:
     return api.get_pump_energy(name, pump)
 
-def set_pump_energy(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_pump_energy(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_pump_energy(name, cs)
 
 
@@ -764,7 +764,7 @@ def get_emitter(name: str, junction: str) -> dict[str, Any]:
     return api.get_emitter(name, junction)
 
 # example: set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0}))
-def set_emitter(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_emitter(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_emitter(name, cs)
 
 
@@ -779,7 +779,7 @@ def get_quality(name: str, node: str) -> dict[str, Any]:
     return api.get_quality(name, node)
 
 # example: set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0}))
-def set_quality(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_quality(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_quality(name, cs)
 
 
@@ -793,14 +793,14 @@ def get_source_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_source(name: str, node: str) -> dict[str, Any]:
     return api.get_source(name, node)
 
-def set_source(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_source(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_source(name, cs)
 
 # example: add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'}))
-def add_source(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_source(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_source(name, cs)
 
-def delete_source(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_source(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_source(name, cs)
 
 
@@ -814,7 +814,7 @@ def get_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_reaction(name: str) -> dict[str, Any]:
     return api.get_reaction(name)
 
-def set_reaction(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_reaction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_reaction(name, cs)
 
 def get_pipe_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -823,7 +823,7 @@ def get_pipe_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_pipe_reaction(name: str, pipe: str) -> dict[str, Any]:
     return api.get_pipe_reaction(name, pipe)
 
-def set_pipe_reaction(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_pipe_reaction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_pipe_reaction(name, cs)
 
 def get_tank_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -832,7 +832,7 @@ def get_tank_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_tank_reaction(name: str, tank: str) -> dict[str, Any]:
     return api.get_tank_reaction(name, tank)
 
-def set_tank_reaction(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_tank_reaction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_tank_reaction(name, cs)
 
 
@@ -846,14 +846,14 @@ def get_mixing_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_mixing(name: str, tank: str) -> dict[str, Any]:
     return api.get_mixing(name, tank)
 
-def set_mixing(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_mixing(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_mixing(name, cs)
 
 # example: add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0}))
-def add_mixing(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_mixing(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_mixing(name, cs)
 
-def delete_mixing(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_mixing(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_mixing(name, cs)
 
 
@@ -867,7 +867,7 @@ def get_time_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_time(name: str) -> dict[str, Any]:
     return api.get_time(name)
 
-def set_time(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_time(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_time(name, cs)
 
 
@@ -888,7 +888,7 @@ def get_option_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_option(name: str) -> dict[str, Any]:
     return api.get_option(name)
 
-def set_option(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_option(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_option_ex(name, cs)
 
 
@@ -902,7 +902,7 @@ def get_option_v3_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_option_v3(name: str) -> dict[str, Any]:
     return api.get_option_v3(name)
 
-def set_option_v3(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_option_v3(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_option_v3_ex(name, cs)
 
 
@@ -971,13 +971,13 @@ def get_vertex_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_vertex(name: str, link: str) -> dict[str, Any]:
     return api.get_vertex(name, link)
 
-def set_vertex(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_vertex(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_vertex(name, cs)
 
-def add_vertex(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_vertex(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_vertex(name, cs)
 
-def delete_vertex(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_vertex(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_vertex(name, cs)
 
 def get_all_vertex_links(name: str) -> list[str]:
@@ -997,13 +997,13 @@ def get_label_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_label(name: str, x: float, y: float) -> dict[str, Any]:
     return api.get_label(name, x, y)
 
-def set_label(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_label(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_label(name, cs)
 
-def add_label(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_label(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_label(name, cs)
 
-def delete_label(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_label(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_label(name, cs)
 
 
@@ -1017,7 +1017,7 @@ def get_backdrop_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_backdrop(name: str) -> dict[str, Any]:
     return api.get_backdrop(name)
 
-def set_backdrop(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_backdrop(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_backdrop(name, cs)
 
 
@@ -1036,16 +1036,16 @@ def get_scada_device_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_scada_device(name: str, id: str) -> dict[str, Any]:
     return api.get_scada_device(name, id)
 
-def set_scada_device(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_scada_device(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_scada_device(name, cs)
 
-def add_scada_device(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_scada_device(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_scada_device(name, cs)
 
-def delete_scada_device(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_scada_device(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_scada_device(name, cs)
 
-def clean_scada_device(name: str) -> "ChangeSet":
+def clean_scada_device(name: str) -> ChangeSet:
     return api.clean_scada_device(name)
 
 def get_all_scada_device_ids(name: str) -> list[str]:
@@ -1067,18 +1067,18 @@ def get_scada_device_data(name: str, device_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 }]}))
 # time format must be 'YYYY-MM-DD HH:MM:SS'
-def set_scada_device_data(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_scada_device_data(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_scada_device_data(name, cs)
 
 # example: add_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
-def add_scada_device_data(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_scada_device_data(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_scada_device_data(name, cs)
 
 # example: delete_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-12 00:02:22'}))
-def delete_scada_device_data(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_scada_device_data(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_scada_device_data(name, cs)
 
-def clean_scada_device_data(name: str) -> "ChangeSet":
+def clean_scada_device_data(name: str) -> ChangeSet:
     return api.clean_scada_device_data(name)
 
 
@@ -1092,16 +1092,16 @@ def get_scada_element_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_scada_element(name: str, id: str) -> dict[str, Any]:
     return api.get_scada_element(name, id)
 
-def set_scada_element(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_scada_element(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_scada_element(name, cs)
 
-def add_scada_element(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_scada_element(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_scada_element(name, cs)
 
-def delete_scada_element(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_scada_element(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_scada_element(name, cs)
 
-def clean_scada_element(name: str) -> "ChangeSet":
+def clean_scada_element(name: str) -> ChangeSet:
     return api.clean_scada_element(name)
 
 def get_all_scada_element_ids(name: str) -> list[str]:
@@ -1142,14 +1142,14 @@ def get_region_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_region(name: str, id: str) -> dict[str, Any]:
     return api.get_region(name, id)
 
-def set_region(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_region(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_region(name, cs)
 
 # example: add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
-def add_region(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_region(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_region(name, cs)
 
-def delete_region(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_region(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_region(name, cs)
 
 
@@ -1172,13 +1172,13 @@ def get_district_metering_area_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_district_metering_area(name: str, id: str) -> dict[str, Any]:
     return api.get_district_metering_area(name, id)
 
-def set_district_metering_area(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_district_metering_area(name, cs)
 
-def add_district_metering_area(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_district_metering_area(name, cs)
 
-def delete_district_metering_area(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_district_metering_area(name, cs)
 
 def get_all_district_metering_area_ids(name: str) -> list[str]:
@@ -1187,10 +1187,10 @@ def get_all_district_metering_area_ids(name: str) -> list[str]:
 def get_all_district_metering_areas(name: str) -> list[dict[str, Any]]:
     return api.get_all_district_metering_areas(name)
 
-def generate_district_metering_area(name: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB, inflate_delta: float = 0.5) -> "ChangeSet":
+def generate_district_metering_area(name: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB, inflate_delta: float = 0.5) -> ChangeSet:
     return api.generate_district_metering_area(name, part_count, part_type, inflate_delta)
 
-def generate_sub_district_metering_area(name: str, dma: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB, inflate_delta: float = 0.5) -> "ChangeSet":
+def generate_sub_district_metering_area(name: str, dma: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB, inflate_delta: float = 0.5) -> ChangeSet:
     return api.generate_sub_district_metering_area(name, dma, part_count, part_type, inflate_delta)
 
 
@@ -1207,13 +1207,13 @@ def get_service_area_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_service_area(name: str, id: str) -> dict[str, Any]:
     return api.get_service_area(name, id)
 
-def set_service_area(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_service_area(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_service_area(name, cs)
 
-def add_service_area(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_service_area(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_service_area(name, cs)
 
-def delete_service_area(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_service_area(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_service_area(name, cs)
 
 def get_all_service_area_ids(name: str) -> list[str]:
@@ -1222,7 +1222,7 @@ def get_all_service_area_ids(name: str) -> list[str]:
 def get_all_service_areas(name: str) -> list[dict[str, Any]]:
     return api.get_all_service_areas(name)
 
-def generate_service_area(name: str, inflate_delta: float = 0.5) -> "ChangeSet":
+def generate_service_area(name: str, inflate_delta: float = 0.5) -> ChangeSet:
     return api.generate_service_area(name, inflate_delta)
 
 
@@ -1239,13 +1239,13 @@ def get_virtual_district_schema(name: str) -> dict[str, dict[str, Any]]:
 def get_virtual_district(name: str, id: str) -> dict[str, Any]:
     return api.get_virtual_district(name, id)
 
-def set_virtual_district(name: str, cs: ChangeSet) -> "ChangeSet":
+def set_virtual_district(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_virtual_district(name, cs)
 
-def add_virtual_district(name: str, cs: ChangeSet) -> "ChangeSet":
+def add_virtual_district(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_virtual_district(name, cs)
 
-def delete_virtual_district(name: str, cs: ChangeSet) -> "ChangeSet":
+def delete_virtual_district(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_virtual_district(name, cs)
 
 def get_all_virtual_district_ids(name: str) -> list[str]:
@@ -1254,7 +1254,7 @@ def get_all_virtual_district_ids(name: str) -> list[str]:
 def get_all_virtual_districts(name: str) -> list[dict[str, Any]]:
     return api.get_all_virtual_districts(name)
 
-def generate_virtual_district(name: str, centers: list[str], inflate_delta: float = 0.5) -> "ChangeSet":
+def generate_virtual_district(name: str, centers: list[str], inflate_delta: float = 0.5) -> ChangeSet:
     return api.generate_virtual_district(name, centers, inflate_delta)