Refine

main.py

@@ -1353,7 +1353,7 @@ async def fastapi_get_all_vertex_links(network: str) -> list[str]:
     return json.dumps(get_all_vertex_links(network))
 
 @app.get('/getallvertices/', response_class = PlainTextResponse)
-async def get_all_vertices(network: str) -> list[dict[str, Any]]:
+async def fastapi_get_all_vertices(network: str) -> list[dict[str, Any]]:
     return json.dumps(get_all_vertices(network))
 
 ############################################################

tjnetwork.py

@@ -178,50 +178,67 @@ PARTITION_TYPE_KWAY = api.PARTITION_TYPE_KWAY
 def list_project() -> list[str]:
     return api.list_project()
 
+
 def have_project(name: str) -> bool:
     return api.have_project(name)
 
+
 def create_project(name: str) -> None:
     return api.create_project(name)
 
+
 def delete_project(name: str) -> None:
     return api.delete_project(name)
 
+
 def clean_project(excluded: list[str] = []) -> None:
     return api.clean_project(excluded)
 
+
 def is_project_open(name: str) -> bool:
     return api.is_project_open(name)
 
+
 def open_project(name: str) -> None:
     return api.open_project(name)
 
+
 def close_project(name: str) -> None:
     return api.close_project(name)
 
+
 def copy_project(source: str, new: str) -> None:
     return api.copy_project(source, new)
 
+
 def read_inp(name: str, inp: str, version: str = '3') -> bool:
     return api.read_inp(name, inp, version)
 
+
 def dump_inp(name: str, inp: str, version: str = '3') -> None:
     return api.dump_inp(name, inp, version)
 
+
 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:
     return api.export_inp(name, version)
 
+
 def run_project(name: str) -> str:
     return epanet.run_project(name)
 
 # put in inp folder, name without extension
+
+
 def run_inp(name: str) -> str:
     return epanet.run_inp(name)
 
 # path is absolute path
+
+
 def dump_output(path: str) -> str:
     return epanet.dump_output(path)
 
@@ -233,90 +250,121 @@ def dump_output(path: str) -> str:
 def get_current_operation(name: str) -> int:
     return api.get_current_operation(name)
 
+
 def execute_undo(name: str, discard: bool = False) -> ChangeSet:
     return api.execute_undo(name, discard)
 
+
 def execute_redo(name: str) -> ChangeSet:
     return api.execute_redo(name)
 
+
 def list_snapshot(name: str) -> list[tuple[int, str]]:
     return api.list_snapshot(name)
 
+
 def have_snapshot(name: str, tag: str) -> bool:
     return api.have_snapshot(name, tag)
 
+
 def have_snapshot_for_operation(name: str, operation: int) -> bool:
     return api.have_snapshot_for_operation(name, operation)
 
+
 def have_snapshot_for_current_operation(name: str) -> bool:
     return api.have_snapshot_for_current_operation(name)
 
+
 def take_snapshot_for_operation(name: str, operation: int, tag: str) -> None:
     return api.take_snapshot_for_operation(name, operation, tag)
 
+
 def take_snapshot_for_current_operation(name: str, tag: str) -> None:
     return api.take_snapshot_for_current_operation(name, tag)
 
 # deprecated ! use take_snapshot_for_current_operation instead
+
+
 def take_snapshot(name: str, tag: str) -> None:
     return api.take_snapshot(name, tag)
 
+
 def update_snapshot(name: str, operation: int, tag: str) -> None:
     return api.update_snapshot(name, operation, tag)
 
+
 def update_snapshot_for_current_operation(name: str, tag: str) -> None:
     return api.update_snapshot_for_current_operation(name, tag)
 
+
 def delete_snapshot(name: str, tag: str) -> None:
     return api.delete_snapshot(name, tag)
 
+
 def delete_snapshot_by_operation(name: str, operation: int) -> None:
     return api.delete_snapshot_by_operation(name, operation)
 
+
 def get_operation_by_snapshot(name: str, tag: str) -> int | None:
     return api.get_operation_by_snapshot(name, tag)
 
+
 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:
     return api.pick_snapshot(name, tag, discard)
 
+
 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:
     return api.sync_with_server(name, operation)
 
 # combine commands as one undo/redo unit
+
+
 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:
     return api.execute_batch_commands(name, cs)
 
+
 def get_restore_operation(name: str) -> int:
     return api.get_restore_operation(name)
 
+
 def set_restore_operation(name: str, operation: int) -> None:
     return api.set_restore_operation(name, operation)
 
+
 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:
     return api.restore(name, discard)
 
+
 def read(name: str, sql: str):
     return api.read(name, sql)
 
+
 def try_read(name: str, sql: str):
     return api.try_read(name, sql)
 
+
 def read_all(name: str, sql: str):
     return api.read_all(name, sql)
 
+
 def write(name: str, sql: str):
     return api.write(name, sql)
 
@@ -328,45 +376,59 @@ def write(name: str, sql: str):
 def is_node(name: str, node_id: str) -> bool:
     return api.is_node(name, node_id)
 
+
 def is_junction(name: str, node_id: str) -> bool:
     return api.is_junction(name, node_id)
 
+
 def is_reservoir(name: str, node_id: str) -> bool:
     return api.is_reservoir(name, node_id)
 
+
 def is_tank(name: str, node_id: str) -> bool:
     return api.is_tank(name, node_id)
 
+
 def is_link(name: str, link_id: str) -> bool:
     return api.is_link(name, link_id)
 
+
 def is_pipe(name: str, link_id: str) -> bool:
     return api.is_pipe(name, link_id)
 
+
 def is_pump(name: str, link_id: str) -> bool:
     return api.is_pump(name, link_id)
 
+
 def is_valve(name: str, link_id: str) -> bool:
     return api.is_valve(name, link_id)
 
+
 def is_curve(name: str, curve_id: str) -> bool:
     return api.is_curve(name, curve_id)
 
+
 def is_pattern(name: str, pattern_id: str) -> bool:
     return api.is_pattern(name, pattern_id)
 
+
 def get_nodes(name: str) -> list[str]:
     return api.get_nodes(name)
 
+
 def get_links(name: str) -> list[str]:
     return api.get_links(name)
 
+
 def get_curves(name: str) -> list[str]:
     return api.get_curves(name)
 
+
 def get_patterns(name: str) -> list[str]:
     return api.get_patterns(name)
 
+
 def get_node_links(name: str, node_id: str) -> list[str]:
     return api.get_node_links(name, node_id)
 
@@ -378,9 +440,11 @@ def get_node_links(name: str, node_id: str) -> list[str]:
 def get_title_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_title_schema(name)
 
+
 def get_title(name: str) -> dict[str, Any]:
     return api.get_title(name)
 
+
 def set_title(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_title(name, cs)
 
@@ -392,16 +456,21 @@ def set_title(name: str, cs: ChangeSet) -> ChangeSet:
 def get_junction_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_junction_schema(name)
 
+
 def get_junction(name: str, id: str) -> dict[str, Any]:
     return api.get_junction(name, id)
 
+
 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:
     return api.add_junction(name, cs)
 
+
 def delete_junction(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_junction_cascade(name, cs)
 
@@ -413,16 +482,21 @@ def delete_junction(name: str, cs: ChangeSet) -> ChangeSet:
 def get_reservoir_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_reservoir_schema(name)
 
+
 def get_reservoir(name: str, id: str) -> dict[str, Any]:
     return api.get_reservoir(name, id)
 
+
 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:
     return api.add_reservoir(name, cs)
 
+
 def delete_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_reservoir_cascade(name, cs)
 
@@ -434,16 +508,21 @@ def delete_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
 def get_tank_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_tank_schema(name)
 
+
 def get_tank(name: str, id: str) -> dict[str, Any]:
     return api.get_tank(name, id)
 
+
 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:
     return api.add_tank(name, cs)
 
+
 def delete_tank(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_tank_cascade(name, cs)
 
@@ -455,16 +534,21 @@ def delete_tank(name: str, cs: ChangeSet) -> ChangeSet:
 def get_pipe_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_pipe_schema(name)
 
+
 def get_pipe(name: str, id: str) -> dict[str, Any]:
     return api.get_pipe(name, id)
 
+
 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:
     return api.add_pipe(name, cs)
 
+
 def delete_pipe(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_pipe_cascade(name, cs)
 
@@ -476,16 +560,21 @@ def delete_pipe(name: str, cs: ChangeSet) -> ChangeSet:
 def get_pump_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_pump_schema(name)
 
+
 def get_pump(name: str, id: str) -> dict[str, Any]:
     return api.get_pump(name, id)
 
+
 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:
     return api.add_pump(name, cs)
 
+
 def delete_pump(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_pump_cascade(name, cs)
 
@@ -497,16 +586,21 @@ def delete_pump(name: str, cs: ChangeSet) -> ChangeSet:
 def get_valve_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_valve_schema(name)
 
+
 def get_valve(name: str, id: str) -> dict[str, Any]:
     return api.get_valve(name, id)
 
+
 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:
     return api.add_valve(name, cs)
 
+
 def delete_valve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_valve_cascade(name, cs)
 
@@ -518,15 +612,19 @@ def delete_valve(name: str, cs: ChangeSet) -> ChangeSet:
 def get_tag_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_tag_schema(name)
 
+
 def get_tags(name: str) -> list[dict[str, Any]]:
     return api.get_tags(name)
 
+
 def get_tag(name: str, t_type: str, id: str) -> dict[str, Any]:
     return api.get_tag(name, t_type, id)
 
 # 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:
     return api.set_tag(name, cs)
 
@@ -538,10 +636,13 @@ def set_tag(name: str, cs: ChangeSet) -> ChangeSet:
 def get_demand_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_demand_schema(name)
 
+
 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:
     return api.set_demand(name, cs)
 
@@ -553,10 +654,13 @@ def set_demand(name: str, cs: ChangeSet) -> ChangeSet:
 def get_status_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_status_schema(name)
 
+
 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:
     return api.set_status(name, cs)
 
@@ -568,16 +672,21 @@ def set_status(name: str, cs: ChangeSet) -> ChangeSet:
 def get_pattern_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_pattern_schema(name)
 
+
 def get_pattern(name: str, id: str) -> dict[str, Any]:
     return api.get_pattern(name, id)
 
+
 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:
     return api.add_pattern(name, cs)
 
+
 def delete_pattern(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_pattern_cascade(name, cs)
 
@@ -589,16 +698,21 @@ def delete_pattern(name: str, cs: ChangeSet) -> ChangeSet:
 def get_curve_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_curve_schema(name)
 
+
 def get_curve(name: str, id: str) -> dict[str, Any]:
     return api.get_curve(name, id)
 
+
 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:
     return api.add_curve(name, cs)
 
+
 def delete_curve(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_curve_cascade(name, cs)
 
@@ -610,10 +724,13 @@ def delete_curve(name: str, cs: ChangeSet) -> ChangeSet:
 def get_control_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_control_schema(name)
 
+
 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:
     return api.set_control(name, cs)
 
@@ -625,10 +742,13 @@ def set_control(name: str, cs: ChangeSet) -> ChangeSet:
 def get_rule_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_rule_schema(name)
 
+
 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:
     return api.set_rule(name, cs)
 
@@ -640,18 +760,23 @@ def set_rule(name: str, cs: ChangeSet) -> ChangeSet:
 def get_energy_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_energy_schema(name)
 
+
 def get_energy(name: str) -> dict[str, Any]:
     return api.get_energy(name)
 
+
 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]]:
     return api.get_pump_energy_schema(name)
 
+
 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:
     return api.set_pump_energy(name, cs)
 
@@ -663,10 +788,13 @@ def set_pump_energy(name: str, cs: ChangeSet) -> ChangeSet:
 def get_emitter_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_emitter_schema(name)
 
+
 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:
     return api.set_emitter(name, cs)
 
@@ -678,10 +806,13 @@ def set_emitter(name: str, cs: ChangeSet) -> ChangeSet:
 def get_quality_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_quality_schema(name)
 
+
 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:
     return api.set_quality(name, cs)
 
@@ -693,16 +824,21 @@ def set_quality(name: str, cs: ChangeSet) -> ChangeSet:
 def get_source_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_source_schema(name)
 
+
 def get_source(name: str, node: str) -> dict[str, Any]:
     return api.get_source(name, node)
 
+
 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:
     return api.add_source(name, cs)
 
+
 def delete_source(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_source(name, cs)
 
@@ -714,27 +850,35 @@ def delete_source(name: str, cs: ChangeSet) -> ChangeSet:
 def get_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_reaction_schema(name)
 
+
 def get_reaction(name: str) -> dict[str, Any]:
     return api.get_reaction(name)
 
+
 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]]:
     return api.get_pipe_reaction_schema(name)
 
+
 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:
     return api.set_pipe_reaction(name, cs)
 
+
 def get_tank_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_tank_reaction_schema(name)
 
+
 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:
     return api.set_tank_reaction(name, cs)
 
@@ -746,16 +890,21 @@ def set_tank_reaction(name: str, cs: ChangeSet) -> ChangeSet:
 def get_mixing_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_mixing_schema(name)
 
+
 def get_mixing(name: str, tank: str) -> dict[str, Any]:
     return api.get_mixing(name, tank)
 
+
 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:
     return api.add_mixing(name, cs)
 
+
 def delete_mixing(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_mixing(name, cs)
 
@@ -767,9 +916,11 @@ def delete_mixing(name: str, cs: ChangeSet) -> ChangeSet:
 def get_time_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_time_schema(name)
 
+
 def get_time(name: str) -> dict[str, Any]:
     return api.get_time(name)
 
+
 def set_time(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_time(name, cs)
 
@@ -788,9 +939,11 @@ def set_time(name: str, cs: ChangeSet) -> ChangeSet:
 def get_option_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_option_schema(name)
 
+
 def get_option(name: str) -> dict[str, Any]:
     return api.get_option(name)
 
+
 def set_option(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_option_ex(name, cs)
 
@@ -802,9 +955,11 @@ def set_option(name: str, cs: ChangeSet) -> ChangeSet:
 def get_option_v3_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_option_v3_schema(name)
 
+
 def get_option_v3(name: str) -> dict[str, Any]:
     return api.get_option_v3(name)
 
+
 def set_option_v3(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_option_v3_ex(name, cs)
 
@@ -824,21 +979,27 @@ def get_node_coord(name: str, node_id: str) -> dict[str, float] | None:
 def get_vertex_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_vertex_schema(name)
 
+
 def get_vertex(name: str, link: str) -> dict[str, Any]:
     return api.get_vertex(name, link)
 
+
 def set_vertex(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_vertex(name, cs)
 
+
 def add_vertex(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_vertex(name, cs)
 
+
 def delete_vertex(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_vertex(name, cs)
 
+
 def get_all_vertex_links(name: str) -> list[str]:
     return api.get_all_vertex_links(name)
 
+
 def get_all_vertices(name: str) -> list[dict[str, Any]]:
     return api.get_all_vertices(name)
 
@@ -850,15 +1011,19 @@ def get_all_vertices(name: str) -> list[dict[str, Any]]:
 def get_label_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_label_schema(name)
 
+
 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:
     return api.set_label(name, cs)
 
+
 def add_label(name: str, cs: ChangeSet) -> ChangeSet:
     return api.add_label(name, cs)
 
+
 def delete_label(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_label(name, cs)
 
@@ -870,9 +1035,11 @@ def delete_label(name: str, cs: ChangeSet) -> ChangeSet:
 def get_backdrop_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_backdrop_schema(name)
 
+
 def get_backdrop(name: str) -> dict[str, Any]:
     return api.get_backdrop(name)
 
+
 def set_backdrop(name: str, cs: ChangeSet) -> ChangeSet:
     return api.set_backdrop(name, cs)
 
@@ -889,24 +1056,31 @@ def set_backdrop(name: str, cs: ChangeSet) -> ChangeSet:
 def get_scada_device_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_scada_device_schema(name)
 
+
 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:
     return api.set_scada_device(name, cs)
 
+
 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:
     return api.delete_scada_device(name, cs)
 
+
 def clean_scada_device(name: str) -> ChangeSet:
     return api.clean_scada_device(name)
 
+
 def get_all_scada_device_ids(name: str) -> list[str]:
     return api.get_all_scada_device_ids(name)
 
+
 def get_all_scada_devices(name: str) -> list[dict[str, Any]]:
     return api.get_all_scada_devices(name)
 
@@ -918,22 +1092,30 @@ def get_all_scada_devices(name: str) -> list[dict[str, Any]]:
 def get_scada_device_data_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_scada_device_data_schema(name)
 
+
 def get_scada_device_data(name: str, device_id: str) -> dict[str, Any]:
     return api.get_scada_device_data(name, device_id)
 
 # 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:
     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:
     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:
     return api.delete_scada_device_data(name, cs)
 
+
 def clean_scada_device_data(name: str) -> ChangeSet:
     return api.clean_scada_device_data(name)
 
@@ -945,24 +1127,31 @@ def clean_scada_device_data(name: str) -> ChangeSet:
 def get_scada_element_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_scada_element_schema(name)
 
+
 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:
     return api.set_scada_element(name, cs)
 
+
 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:
     return api.delete_scada_element(name, cs)
 
+
 def clean_scada_element(name: str) -> ChangeSet:
     return api.clean_scada_element(name)
 
+
 def get_all_scada_element_ids(name: str) -> list[str]:
     return api.get_all_scada_element_ids(name)
 
+
 def get_all_scada_elements(name: str) -> list[dict[str, Any]]:
     return api.get_all_scada_elements(name)
 
@@ -974,18 +1163,23 @@ def get_all_scada_elements(name: str) -> list[dict[str, Any]]:
 def get_nodes_in_boundary(name: str, boundary: list[tuple[float, float]]) -> list[str]:
     return api.get_nodes_in_boundary(name, boundary)
 
+
 def get_nodes_in_region(name: str, region_id: str) -> list[str]:
     return api.get_nodes_in_region(name, region_id)
 
+
 def calculate_convex_hull(name: str, nodes: list[str]) -> list[tuple[float, float]]:
     return api.calculate_convex_hull(name, nodes)
 
+
 def calculate_boundary(name: str, nodes: list[str]) -> list[tuple[float, float]]:
     return api.calculate_boundary(name, nodes)
 
+
 def inflate_boundary(name: str, boundary: list[tuple[float, float]], delta: float = 0.5) -> list[tuple[float, float]]:
     return api.inflate_boundary(name, boundary, delta)
 
+
 def inflate_region(name: str, region_id: str, delta: float = 0.5) -> list[tuple[float, float]]:
     return api.inflate_region(name, region_id, delta)
 
@@ -997,16 +1191,21 @@ def inflate_region(name: str, region_id: str, delta: float = 0.5) -> list[tuple[
 def get_region_schema(name: str) -> dict[str, dict[str, Any]]:
     return api.get_region_schema(name)
 
+
 def get_region(name: str, id: str) -> dict[str, Any]:
     return api.get_region(name, id)
 
+
 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:
     return api.add_region(name, cs)
 
+
 def delete_region(name: str, cs: ChangeSet) -> ChangeSet:
     return api.delete_region(name, cs)
 
@@ -1018,6 +1217,7 @@ def delete_region(name: str, cs: ChangeSet) -> ChangeSet:
 def distribute_demand_to_nodes(name: str, demand: float, nodes: list[str], type: str = DISTRIBUTION_TYPE_ADD) -> ChangeSet:
     return api.distribute_demand_to_nodes(name, demand, nodes, type)
 
+
 def distribute_demand_to_region(name: str, demand: float, region: str, type: str = DISTRIBUTION_TYPE_ADD) -> ChangeSet:
     return api.distribute_demand_to_region(name, demand, region, type)