Accept Merge Request #28: (api -> master)

Merge Request: Add all node & link api

Created By: @王琼钰
Accepted By: @王琼钰
URL: https://tjwater.coding.net/p/tjwatercloud/d/TJWaterServer/git/merge/28

.gitignore

@@ -1,6 +1,9 @@
 # python cache
 __pycache__/
 
+# pytest
+.pytest_cache/
+
 # epanet
 *.rpt
 *.opt

api/__init__.py

@@ -21,3 +21,29 @@ from .s1_title import set_title, get_title
 from .s2_junctions import add_junction, delete_junction
 from .s2_junctions import get_junction_elevation, get_junction_demand, get_junction_pattern, get_junction_coord
 from .s2_junctions import set_junction_elevation, set_junction_demand, set_junction_pattern, set_junction_coord
+
+from .s3_reservoirs import add_reservoir, delete_reservoir
+from .s3_reservoirs import get_reservoir_head, get_reservoir_pattern, get_reservoir_coord
+from .s3_reservoirs import set_reservoir_head, set_reservoir_pattern, set_reservoir_coord
+
+from .s4_tanks import OVERFLOW_YES, OVERFLOW_NO
+from .s4_tanks import add_tank, delete_tank
+from .s4_tanks import get_tank_elevation, get_tank_init_level, get_tank_min_level, get_tank_max_level, get_tank_diameter, get_tank_min_vol, get_tank_vol_curve, get_tank_overflow, get_tank_coord
+from .s4_tanks import set_tank_elevation, set_tank_init_level, set_tank_min_level, set_tank_max_level, set_tank_diameter, set_tank_min_vol, set_tank_vol_curve, set_tank_overflow, set_tank_coord
+
+from .s5_pipes import PIPE_STATUS_OPEN, PIPE_STATUS_CLOSED, PIPE_STATUS_CV
+from .s5_pipes import add_pipe, delete_pipe
+from .s5_pipes import get_pipe_node1, get_pipe_node2, get_pipe_length, get_pipe_diameter, get_pipe_roughness, get_pipe_minor_loss, get_pipe_status
+from .s5_pipes import set_pipe_node1, set_pipe_node2, set_pipe_length, set_pipe_diameter, set_pipe_roughness, set_pipe_minor_loss, set_pipe_status
+
+from .s6_pumps import add_pump, delete_pump
+from .s6_pumps import get_pump_node1, get_pump_node2
+from .s6_pumps import set_pump_node1, set_pump_node2
+# TODO: more properties...
+
+from .s7_valves import VALVES_TYPE_PRV, VALVES_TYPE_PSV, VALVES_TYPE_PBV, VALVES_TYPE_FCV, VALVES_TYPE_TCV, VALVES_TYPE_GPV
+from .s7_valves import add_valve, delete_valve
+from .s7_valves import get_valve_node1, get_valve_node2, get_valve_diameter, get_valve_type, get_valve_setting, get_valve_minor_loss
+from .s7_valves import set_valve_node1, set_valve_node2, set_valve_diameter, set_valve_type, set_valve_setting, set_valve_minor_loss
+
+# from .s24_coordinates import get_node_coord, set_node_coord

api/project.py

@@ -4,13 +4,13 @@ from .connection import g_conn_dict as conn
 # no undo/redo
 
 def have_project(name: str) -> bool:
-    with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:
+    with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute(f"select * from pg_database where datname = '{name}'")
             return cur.rowcount > 0
 
 def copy_project(source: str, new: str) -> None:
-    with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:
+    with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute(f"create database {new} with template = {source}")
 
@@ -18,12 +18,12 @@ def create_project(name: str) -> None:
     return copy_project('project', name)
 
 def delete_project(name: str) -> None:
-    with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:
+    with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute(f"drop database {name}")
 
 def open_project(name: str) -> None:
-    conn[name] = pg.connect(conninfo=f"dbname={name}", autocommit=True)
+    conn[name] = pg.connect(conninfo=f"dbname={name} host=127.0.0.1", autocommit=True)
 
 def is_project_open(name: str) -> bool:
     return name in conn

api/s0_base.py

@@ -1,59 +1,74 @@
 from psycopg.rows import dict_row, Row
 from .connection import g_conn_dict as conn
+from .operation import *
+from .change_set import ChangeSet
+
 
 _NODE = "_node"
 _LINK = "_link"
 _CURVE = "_curve"
 _PATTERN = "_pattern"
 
-JUNCTION = "JUNCTION"
+JUNCTION = "junction"
-RESERVOIR = "RESERVOIR"
+RESERVOIR = "reservoir"
-TANK = "TANK"
+TANK = "tank"
-PIPE = "PIPE"
+PIPE = "pipe"
-PUMP = "PUMP"
+PUMP = "pump"
-VALVE = "VALVE"
+VALVE = "valve"
+
 
 def _get_from(name: str, id: str, base_type: str) -> Row | None:
     with conn[name].cursor(row_factory=dict_row) as cur:
         cur.execute(f"select * from {base_type} where id = '{id}'")
         return cur.fetchone()
 
+
 def is_node(name: str, id: str) -> bool:
     return _get_from(name, id, _NODE) != None
 
+
 def is_junction(name: str, id: str) -> bool:
     row = _get_from(name, id, _NODE)
     return row != None and row['type'] == JUNCTION
 
+
 def is_reservoir(name: str, id: str) -> bool:
     row = _get_from(name, id, _NODE)
     return row != None and row['type'] == RESERVOIR
 
+
 def is_tank(name: str, id: str) -> bool:
     row = _get_from(name, id, _NODE)
     return row != None and row['type'] == TANK
 
+
 def is_link(name: str, id: str) -> bool:
-    return _get_from(name, id, _LINK) != {}
+    return _get_from(name, id, _LINK) != None
+
 
 def is_pipe(name: str, id: str) -> bool:
     row = _get_from(name, id, _LINK)
     return row != None and row['type'] == PIPE
 
+
 def is_pump(name: str, id: str) -> bool:
     row = _get_from(name, id, _LINK)
     return row != None and row['type'] == PUMP
 
+
 def is_valve(name: str, id: str) -> bool:
     row = _get_from(name, id, _LINK)
     return row != None and row['type'] == VALVE
 
+
 def is_curve(name: str, id: str) -> bool:
     return _get_from(name, id, _CURVE) != None
 
+
 def is_pattern(name: str, id: str) -> bool:
     return _get_from(name, id, _PATTERN) != None
 
+
 def _get_all(name: str, base_type: str) -> list[str]:
     ids : list[str] = []
     with conn[name].cursor(row_factory=dict_row) as cur:
@@ -62,14 +77,105 @@ def _get_all(name: str, base_type: str) -> list[str]:
             ids.append(record['id'])
     return ids
 
+
 def get_nodes(name: str) -> list[str]:
     return _get_all(name, _NODE)
 
+
 def get_links(name: str) -> list[str]:
     return _get_all(name, _LINK)
 
+
 def get_curves(name: str) -> list[str]:
     return _get_all(name, _CURVE)
 
+
 def get_patterns(name: str) -> list[str]:
     return _get_all(name, _PATTERN)
+
+
+def add_node(name: str, node_type: str, id: str, x: float, y: float, table_sql: str, table_undo_sql: str) -> ChangeSet:
+    if is_node(name, id):
+        return ChangeSet()
+
+    with conn[name].cursor() as cur:
+        sql = f"insert into _node (id, type) values ('{id}', '{node_type}'); "
+        sql += table_sql
+        sql += f" insert into coordinates (node, coord) values ('{id}', '({x}, {y})');"
+        cur.execute(sql)
+
+        redo = sql.replace("'", '"')
+        undo = f'delete from coordinates where node = "{id}"; '
+        undo += table_undo_sql
+        undo += f' delete from _node where id = "{id}";'
+        add_operation(name, redo, undo)
+
+    change = ChangeSet()
+    change.add(node_type, id)
+    return change
+
+
+def delete_node(name: str, node_type: str, id: str, table_sql: str, table_undo_sql: str) -> ChangeSet:
+    if not is_node(name, id):
+        return ChangeSet()
+
+    with conn[name].cursor(row_factory=dict_row) as cur:
+        cur.execute(f"select * from coordinates where node = '{id}'")
+        row = cur.fetchone()
+        if row == None:
+            return ChangeSet()
+
+        coord = row['coord']
+
+        sql = f"delete from coordinates where node = '{id}'; "
+        sql += table_sql
+        sql += f" delete from _node where id = '{id}';"
+        cur.execute(sql)
+
+        redo = sql.replace("'", '"')
+        undo = f'insert into _node (id, type) values ("{id}", "{node_type}"); '
+        undo += table_undo_sql
+        undo += f' insert into coordinates (node, coord) values ("{id}", "{coord}");'
+        add_operation(name, redo, undo)
+
+    change = ChangeSet()
+    change.delete(node_type, id)
+    return change
+
+
+def add_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: str) -> ChangeSet:
+    if is_link(name, id):
+        return ChangeSet()
+
+    with conn[name].cursor() as cur:
+        sql = f"insert into _link (id, type) values ('{id}', '{link_type}'); "
+        sql += table_sql
+        cur.execute(sql)
+
+        redo = sql.replace("'", '"')
+        undo = table_undo_sql
+        undo += f' delete from _link where id = "{id}";'
+        add_operation(name, redo, undo)
+
+    change = ChangeSet()
+    change.add(link_type, id)
+    return change
+
+
+def delete_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: str) -> ChangeSet:
+    if not is_link(name, id):
+        return ChangeSet()
+
+    with conn[name].cursor(row_factory=dict_row) as cur:
+        sql = table_sql
+        sql += f" delete from _link where id = '{id}';"
+        cur.execute(sql)
+
+        redo = sql.replace("'", '"')
+        undo = f'insert into _link (id, type) values ("{id}", "{link_type}"); '
+        undo += table_undo_sql
+        add_operation(name, redo, undo)
+
+    change = ChangeSet()
+    change.delete(link_type, id)
+    return change

api/s24_coordinates.py

@@ -0,0 +1,43 @@
+from psycopg.rows import dict_row, Row
+from .connection import g_conn_dict as conn
+from .s0_base import *
+from .operation import *
+from .change_set import ChangeSet
+
+
+def _to_point(coord: str) -> dict[str, float]:
+    coord = coord.removeprefix('(')
+    coord = coord.removesuffix(')')
+    coord = coord.split(',')
+    return { 'x': float(coord[0]), 'y': float(coord[1]) }
+
+
+def get_node_coord(name: str, id: str) -> dict[str, float] | None:
+    with conn[name].cursor(row_factory=dict_row) as cur:
+        cur.execute(f"select * from coordinates where node = '{id}'")
+        row = cur.fetchone()
+        if row == None:
+            return None
+        
+        coord = str(row['coord'])
+        return _to_point(coord)
+
+
+def set_node_coord(name: str, node_type: str, id: str, x: float, y: float) -> ChangeSet:
+    old = get_node_coord(name, id)
+    if old == None:
+        return ChangeSet()
+
+    old_x, old_y = old['x'], old['y']
+
+    with conn[name].cursor() as cur:
+        sql = f"update coordinates set coord = '({x},{y})' where node = '{id}'"
+        cur.execute(sql)
+
+        redo = sql.replace("'", '"')
+        undo = f'update coordinates set coord = "({old_x},{old_y})" where node = "{id}"'
+        add_operation(name, redo, undo)
+
+    change = ChangeSet()
+    change.update(node_type, id, 'coord', 'point', str({'x': x, 'y': y}))
+    return change

api/s2_junctions.py

@@ -1,77 +1,43 @@
-from psycopg.rows import dict_row, Row
+from psycopg.rows import Row
-from .connection import g_conn_dict as conn
 from .s0_base import *
-from .operation import *
 from .change_set import ChangeSet
+from .s24_coordinates import *
+from .utility import *
+
 
 def add_junction(name: str, id: str, x: float, y: float, elevation: float) -> ChangeSet:
-    if is_node(name, id):
+    sql = f"insert into junctions (id, elevation) values ('{id}', {elevation});"
-        return
+    undo_sql = f'delete from junctions where id = "{id}";'
+    return add_node(name, JUNCTION, id, x, y, sql, undo_sql)
 
-    with conn[name].cursor() as cur:
-        sql = f"insert into _node (id, type) values ('{id}', 'JUNCTION');"
-        sql += f" insert into junctions (id, elevation) values ('{id}', {elevation});"
-        sql += f" insert into coordinates (node, coord) values ('{id}', '({x}, {y})');"
-        cur.execute(sql)
 
-        redo = sql.replace("'", '"')
+def _get_junction(name: str, id: str) -> Row | None:
-        undo = f'delete from coordinates where node = "{id}";'
+    return query(name, f"select elevation, demand, pattern from junctions where id = '{id}'")
-        undo += f' delete from junctions where id = "{id}";'
-        undo += f' delete from _node where id = "{id}";'
-        add_operation(name, redo, undo)
-
-    change = ChangeSet()
-    change.add('junction', id)
-    return change
 
 
 def delete_junction(name: str, id: str) -> ChangeSet:
     if not is_junction(name, id):
-        return
+        return ChangeSet()
 
-    with conn[name].cursor(row_factory=dict_row) as cur:
+    row = _get_junction(name, id)
-        cur.execute(f"select * from junctions where id = '{id}'")
-        row = cur.fetchone()
     if row == None:
-            return
+        return ChangeSet()
 
     elevation = row['elevation']
-        demand = 'NULL' if row['demand'] == None else row['demand']
+    demand = decorate(row['demand'], 'float', True)
-        pattern = 'NULL' if row['pattern'] == None else row['pattern']
+    pattern = decorate(row['pattern'], 'str', True)
-        pattern = f'"{pattern}"' if pattern != 'NULL' else pattern
 
-        cur.execute(f"select * from coordinates where node = '{id}'")
+    sql = f"delete from junctions where id = '{id}';"
-        row = cur.fetchone()
+    undo_sql = f'insert into junctions (id, elevation, demand, pattern) values ("{id}", {elevation}, {demand}, {pattern});'
-        if row == None:
-            return
 
-        coord = row['coord']
+    return delete_node(name, JUNCTION, id, sql, undo_sql)
 
-        sql = f"delete from coordinates where node = '{id}';"
-        sql += f" delete from junctions where id = '{id}';"
-        sql += f" delete from _node where id = '{id}';"
-        cur.execute(sql)
-
-        redo = sql.replace("'", '"')
-        undo = f'insert into _node (id, type) values ("{id}", "JUNCTION");'
-        undo += f' insert into junctions (id, elevation, demand, pattern) values ("{id}", {elevation}, {demand}, {pattern});'
-        undo += f' insert into coordinates (node, coord) values ("{id}", "{coord}");'
-        add_operation(name, redo, undo)
-
-    change = ChangeSet()
-    change.delete('junction', id)
-    return change
-
-
-def _get_junction(name: str, id: str) -> Row | None:
-    with conn[name].cursor(row_factory=dict_row) as cur:
-        cur.execute(f"select elevation, demand, pattern from junctions where id = '{id}'")
-        return cur.fetchone()
 
 def get_junction_elevation(name: str, id: str) -> float | None:
     row = _get_junction(name, id)
     return float(row['elevation']) if row != None else None
 
+
 def get_junction_demand(name: str, id: str) -> float | str | None:
     row = _get_junction(name, id)
     if row != None:
@@ -79,6 +45,7 @@ def get_junction_demand(name: str, id: str) -> float | str | None:
     else:
         return None
 
+
 def get_junction_pattern(name: str, id: str) -> str | None:
     row = _get_junction(name, id)
     if row != None:
@@ -86,103 +53,39 @@ def get_junction_pattern(name: str, id: str) -> str | None:
     else:
         return None
 
-def _to_point(coord: str) -> dict[str, float]:
-    coord = coord.removeprefix('(')
-    coord = coord.removesuffix(')')
-    coord = coord.split(',')
-    return { 'x': float(coord[0]), 'y': float(coord[1]) }
 
 def get_junction_coord(name: str, id: str) -> dict[str, float] | None:
-    with conn[name].cursor(row_factory=dict_row) as cur:
+    return get_node_coord(name, id)
-        cur.execute(f"select * from coordinates where node = '{id}'")
+
-        row = cur.fetchone()
+
-        if row == None:
+def _set_junction(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
-            return None
+    if not is_junction(name, id):
+        return ChangeSet()
+
+    row = _get_junction(name, id)
+    if row == None:
+        return ChangeSet()
+
+    return update(name, JUNCTION, 'junctions', 'id', id, key, key_type, row[key], value, optional)
 
-        coord = str(row['coord'])
-        return _to_point(coord)
 
 def set_junction_elevation(name: str, id: str, elevation: float) -> ChangeSet:
-    if not is_junction(name, id):
+    return _set_junction(name, id, 'elevation', 'float', str(elevation))
-        return
-
-    old = get_junction_elevation(name, id)
-    if old == None:
-        return
-
-    with conn[name].cursor() as cur:
-        sql = f"update junctions set elevation = {elevation} where id = '{id}'"
-        cur.execute(sql)
-        redo = sql.replace("'", '"')
-        undo = f'update junctions set elevation = {old} where id = "{id}"'
-        add_operation(name, redo, undo)
-
-    change = ChangeSet()
-    change.update('junction', id, 'elevation', 'float', str(elevation))
-    return change
 
 
 def set_junction_demand(name: str, id: str, demand: float) -> ChangeSet:
-    if not is_junction(name, id):
+    return _set_junction(name, id, 'demand', 'float', str(demand), True)
-        return
-
-    old = get_junction_demand(name, id)
-    if old == None:
-        return
-
-    with conn[name].cursor() as cur:
-        sql = f"update junctions set demand = {demand} where id = '{id}'"
-        cur.execute(sql)
-        redo = sql.replace("'", '"')
-        undo = f'update junctions set demand = {old} where id = "{id}"'
-        add_operation(name, redo, undo)
-
-    change = ChangeSet()
-    change.update('junction', id, 'demand', 'float', str(demand))
-    return change
 
 
 def set_junction_pattern(name: str, id: str, pattern: str) -> ChangeSet:
-    if not is_junction(name, id):
+    if not is_pattern(name, pattern):
-        return
+        return ChangeSet()
-    if not is_pattern(name, id):
-        return
 
-    old = get_junction_pattern(name, id)
+    return _set_junction(name, id, 'pattern', 'str', pattern, True)
-    if old == None:
-        return
-
-    old = f'"{old}"' if old != 'NULL' else old
-
-    with conn[name].cursor() as cur:
-        sql = f"update junctions set pattern = '{pattern}' where id = '{id}'"
-        cur.execute(sql)
-        redo = sql.replace("'", '"')
-        undo = f'update junctions set pattern = {old} where id = "{id}"'
-        add_operation(name, redo, undo)
-
-    change = ChangeSet()
-    change.update('junction', id, 'pattern', 'float', str(pattern))
-    return change
 
 
 def set_junction_coord(name: str, id: str, x: float, y: float) -> ChangeSet:
     if not is_junction(name, id):
-        return
+        return ChangeSet()
 
-    old = get_junction_coord(name, id)
+    return set_node_coord(name, JUNCTION, id, x, y)
-    if old == None:
-        return
-    old_x, old_y = old['x'], old['y']
-
-    with conn[name].cursor() as cur:
-        sql = f"update coordinates set coord = '({x},{y})' where node = '{id}'"
-        cur.execute(sql)
-
-        redo = sql.replace("'", '"')
-        undo = f'update coordinates set coord = "({old_x},{old_y})" where node = "{id}"'
-        add_operation(name, redo, undo)
-
-    change = ChangeSet()
-    change.update('junction', id, 'coord', 'point', str({'x': x, 'y': y}))
-    return change

api/s3_reservoirs.py

@@ -0,0 +1,78 @@
+from psycopg.rows import Row
+from .s0_base import *
+from .change_set import ChangeSet
+from .s24_coordinates import *
+from .utility import *
+
+
+def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> ChangeSet:
+    sql = f"insert into reservoirs (id, head) values ('{id}', {head});"
+    undo_sql = f'delete from reservoirs where id = "{id}";'
+    return add_node(name, RESERVOIR, id, x, y, sql, undo_sql)
+
+
+def _get_reservoir(name: str, id: str) -> Row | None:
+    return query(name, f"select head, pattern from reservoirs where id = '{id}'")
+
+
+def delete_reservoir(name: str, id: str) -> ChangeSet:
+    if not is_reservoir(name, id):
+        return ChangeSet()
+
+    row = _get_reservoir(name, id)
+    if row == None:
+        return ChangeSet()
+
+    head = row['head']
+    pattern = decorate(row['pattern'], 'str', True)
+
+    sql = f"delete from reservoirs where id = '{id}';"
+    undo_sql = f'insert into reservoirs (id, head, pattern) values ("{id}", {head}, {pattern});'
+
+    return delete_node(name, RESERVOIR, id, sql, undo_sql)
+
+
+def get_reservoir_head(name: str, id: str) -> float | None:
+    row = _get_reservoir(name, id)
+    return float(row['head']) if row != None else None
+
+
+def get_reservoir_pattern(name: str, id: str) -> str | None:
+    row = _get_reservoir(name, id)
+    if row != None:
+        return row['pattern'] if row['pattern'] != None else 'NULL'
+    else:
+        return None
+
+
+def get_reservoir_coord(name: str, id: str) -> dict[str, float] | None:
+    return get_node_coord(name, id)
+
+
+def _set_reservoir(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
+    if not is_reservoir(name, id):
+        return ChangeSet()
+
+    row = _get_reservoir(name, id)
+    if row == None:
+        return ChangeSet()
+
+    return update(name, RESERVOIR, 'reservoirs', 'id', id, key, key_type, row[key], value, optional)
+
+
+def set_reservoir_head(name: str, id: str, head: float) -> ChangeSet:
+    return _set_reservoir(name, id, 'head', 'float', str(head))
+
+
+def set_reservoir_pattern(name: str, id: str, pattern: str) -> ChangeSet:
+    if not is_pattern(name, id):
+        return ChangeSet()
+
+    return _set_reservoir(name, id, 'pattern', 'str', pattern, True)
+
+
+def set_reservoir_coord(name: str, id: str, x: float, y: float) -> ChangeSet:
+    if not is_reservoir(name, id):
+        return ChangeSet()
+
+    return set_node_coord(name, RESERVOIR, id, x, y)

api/s4_tanks.py

@@ -0,0 +1,148 @@
+from psycopg.rows import Row
+from .s0_base import *
+from .change_set import ChangeSet
+from .s24_coordinates import *
+from .utility import *
+
+
+OVERFLOW_YES = 'yes'
+OVERFLOW_NO = 'no'
+
+
+def add_tank(name: str, id: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
+    sql = f"insert into tanks (id, elevation, init_level, min_level, max_level, diameter, min_vol) values ('{id}', {elevation}, {init_level}, {min_level}, {max_level}, {diameter}, {min_vol});"
+    undo_sql = f'delete from tanks where id = "{id}";'
+    return add_node(name, TANK, id, x, y, sql, undo_sql)
+
+
+def _get_tank(name: str, id: str) -> Row | None:
+    return query(name, f"select elevation, init_level, min_level, max_level, diameter, min_vol, vol_curve, overflow from tanks where id = '{id}'")
+
+
+def delete_tank(name: str, id: str) -> ChangeSet:
+    if not is_tank(name, id):
+        return ChangeSet()
+
+    row = _get_tank(name, id)
+    if row == None:
+        return ChangeSet()
+
+    elevation = row['elevation']
+    init_level = row['init_level']
+    min_level = row['min_level']
+    max_level = row['max_level']
+    diameter = row['diameter']
+    min_vol = row['min_vol']
+    vol_curve = decorate(row['vol_curve'], 'str', True)
+    overflow = decorate(row['overflow'], 'str', True)
+
+    sql = f"delete from tanks where id = '{id}';"
+    undo_sql = f'insert into tanks (id, elevation, init_level, min_level, max_level, diameter, min_vol, vol_curve, overflow) values ("{id}", {elevation}, {init_level}, {min_level}, {max_level}, {diameter}, {min_vol}, {vol_curve}, {overflow});'
+
+    return delete_node(name, TANK, id, sql, undo_sql)
+
+
+def get_tank_elevation(name: str, id: str) -> float | None:
+    row = _get_tank(name, id)
+    return float(row['elevation']) if row != None else None
+
+
+def get_tank_init_level(name: str, id: str) -> float | None:
+    row = _get_tank(name, id)
+    return float(row['init_level']) if row != None else None
+
+
+def get_tank_min_level(name: str, id: str) -> float | None:
+    row = _get_tank(name, id)
+    return float(row['min_level']) if row != None else None
+
+
+def get_tank_max_level(name: str, id: str) -> float | None:
+    row = _get_tank(name, id)
+    return float(row['max_level']) if row != None else None
+
+
+def get_tank_diameter(name: str, id: str) -> float | None:
+    row = _get_tank(name, id)
+    return float(row['diameter']) if row != None else None
+
+
+def get_tank_min_vol(name: str, id: str) -> float | None:
+    row = _get_tank(name, id)
+    return float(row['min_vol']) if row != None else None
+
+
+def get_tank_vol_curve(name: str, id: str) -> str | None:
+    row = _get_tank(name, id)
+    if row != None:
+        return row['vol_curve'] if row['vol_curve'] != None else 'NULL'
+    else:
+        return None
+
+
+def get_tank_overflow(name: str, id: str) -> str | None:
+    row = _get_tank(name, id)
+    if row != None:
+        return row['overflow'] if row['overflow'] != None else 'NULL'
+    else:
+        return None
+
+
+def get_tank_coord(name: str, id: str) -> dict[str, float] | None:
+    return get_node_coord(name, id)
+
+
+def _set_tank(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
+    if not is_tank(name, id):
+        return ChangeSet()
+
+    row = _get_tank(name, id)
+    if row == None:
+        return ChangeSet()
+
+    return update(name, TANK, 'tanks', 'id', id, key, key_type, row[key], value, optional)
+
+
+def set_tank_elevation(name: str, id: str, elevation: float) -> ChangeSet:
+    return _set_tank(name, id, 'elevation', 'float', elevation)
+
+
+def set_tank_init_level(name: str, id: str, init_level: float) -> ChangeSet:
+    return _set_tank(name, id, 'init_level', 'float', init_level)
+
+
+def set_tank_min_level(name: str, id: str, min_level: float) -> ChangeSet:
+    return _set_tank(name, id, 'min_level', 'float', min_level)
+
+
+def set_tank_max_level(name: str, id: str, max_level: float) -> ChangeSet:
+    return _set_tank(name, id, 'max_level', 'float', max_level)
+
+
+def set_tank_diameter(name: str, id: str, diameter: float) -> ChangeSet:
+    return _set_tank(name, id, 'diameter', 'float', diameter)
+
+
+def set_tank_min_vol(name: str, id: str, min_vol: float) -> ChangeSet:
+    return _set_tank(name, id, 'min_vol', 'float', min_vol)
+
+
+def set_tank_vol_curve(name: str, id: str, vol_curve: str) -> ChangeSet:
+    if not is_curve(name, vol_curve):
+        return ChangeSet()
+
+    return _set_tank(name, id, 'vol_curve', 'str', vol_curve, True)
+
+
+def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet:
+    if overflow != OVERFLOW_YES and overflow != OVERFLOW_NO:
+        return ChangeSet()
+
+    return _set_tank(name, id, 'overflow', 'str', overflow)
+
+
+def set_tank_coord(name: str, id: str, x: float, y: float) -> ChangeSet:
+    if not is_tank(name, id):
+        return ChangeSet()
+
+    return set_node_coord(name, TANK, id, x, y)

api/s5_pipes.py

@@ -0,0 +1,132 @@
+from psycopg.rows import Row
+from .s0_base import *
+from .change_set import ChangeSet
+from .utility import *
+
+
+PIPE_STATUS_OPEN = 'open'
+PIPE_STATUS_CLOSED = 'closed'
+PIPE_STATUS_CV = 'cv'
+
+
+def add_pipe(name: str, id: str, node1: str, node2: str, length: float = 0, diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
+    if not is_node(name, node1):
+        return ChangeSet()
+    if not is_node(name, node2):
+        return ChangeSet()
+    if node1 == node2:
+        return ChangeSet()
+
+    if status != PIPE_STATUS_OPEN and status != PIPE_STATUS_CLOSED and status != PIPE_STATUS_CV:
+        return ChangeSet()
+
+    sql = f"insert into pipes (id, node1, node2, length, diameter, roughness, minor_loss, status) values ('{id}', '{node1}', '{node2}', {length}, {diameter}, {roughness}, {minor_loss}, '{status}');"
+    undo_sql = f'delete from pipes where id = "{id}";'
+    return add_link(name, PIPE, id, sql, undo_sql)
+
+
+def _get_pipe(name: str, id: str) -> Row | None:
+    return query(name, f"select node1, node2, length, diameter, roughness, minor_loss, status from pipes where id = '{id}'")
+
+
+def delete_pipe(name: str, id: str) -> ChangeSet:
+    if not is_pipe(name, id):
+        return ChangeSet()
+
+    row = _get_pipe(name, id)
+    if row == None:
+        return ChangeSet()
+
+    node1, node2, length, diameter, roughness, minor_loss, status = row['node1'], row['node2'], row['length'], row['diameter'], row['roughness'], row['minor_loss'], row['status']
+
+    sql = f"delete from pipes where id = '{id}';"
+    undo_sql = f'insert into pipes (id, node1, node2, length, diameter, roughness, minor_loss, status) values ("{id}", "{node1}", "{node2}", {length}, {diameter}, {roughness}, {minor_loss}, "{status}");'
+
+    return delete_link(name, PIPE, id, sql, undo_sql)
+
+
+def get_pipe_node1(name: str, id: str) -> str | None:
+    row = _get_pipe(name, id)
+    return row['node1'] if row != None else None
+
+
+def get_pipe_node2(name: str, id: str) -> str | None:
+    row = _get_pipe(name, id)
+    return row['node2'] if row != None else None
+
+
+def get_pipe_length(name: str, id: str) -> float | None:
+    row = _get_pipe(name, id)
+    return float(row['length']) if row != None else None
+
+
+def get_pipe_diameter(name: str, id: str) -> float | None:
+    row = _get_pipe(name, id)
+    return float(row['diameter']) if row != None else None
+
+
+def get_pipe_roughness(name: str, id: str) -> float | None:
+    row = _get_pipe(name, id)
+    return float(row['roughness']) if row != None else None
+
+
+def get_pipe_minor_loss(name: str, id: str) -> float | None:
+    row = _get_pipe(name, id)
+    return float(row['minor_loss']) if row != None else None
+
+
+def get_pipe_status(name: str, id: str) -> str | None:
+    row = _get_pipe(name, id)
+    return row['status'] if row != None else None
+
+
+def _set_pipe(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
+    if not is_pipe(name, id):
+        return ChangeSet()
+
+    row = _get_pipe(name, id)
+    if row == None:
+        return ChangeSet()
+
+    return update(name, PIPE, 'pipes', 'id', id, key, key_type, row[key], value, optional)
+
+
+def set_pipe_node1(name: str, id: str, node1: str) -> ChangeSet:
+    if not is_node(name, node1):
+        return ChangeSet()
+    if get_pipe_node2(name, id) == node1:
+        return ChangeSet()
+
+    return _set_pipe(name, id, 'node1', 'str', str(node1))
+
+
+def set_pipe_node2(name: str, id: str, node2: str) -> ChangeSet:
+    if not is_node(name, node2):
+        return ChangeSet()
+    if get_pipe_node1(name, id) == node2:
+        return ChangeSet()
+
+    return _set_pipe(name, id, 'node2', 'str', str(node2))
+
+
+def set_pipe_length(name: str, id: str, length: float) -> ChangeSet:
+    return _set_pipe(name, id, 'length', 'float', str(length))
+
+
+def set_pipe_diameter(name: str, id: str, diameter: float) -> ChangeSet:
+    return _set_pipe(name, id, 'diameter', 'float', str(diameter))
+
+
+def set_pipe_roughness(name: str, id: str, roughness: float) -> ChangeSet:
+    return _set_pipe(name, id, 'roughness', 'float', str(roughness))
+
+
+def set_pipe_minor_loss(name: str, id: str, minor_loss: float) -> ChangeSet:
+    return _set_pipe(name, id, 'minor_loss', 'float', str(minor_loss))
+
+
+def set_pipe_status(name: str, id: str, status: float) -> ChangeSet:
+    if status != PIPE_STATUS_OPEN and status != PIPE_STATUS_CLOSED and status != PIPE_STATUS_CV:
+        return ChangeSet()
+
+    return _set_pipe(name, id, 'status', 'str', str(status))

api/s6_pumps.py

@@ -0,0 +1,88 @@
+from psycopg.rows import Row
+from .s0_base import *
+from .change_set import ChangeSet
+from .utility import *
+
+
+def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet:
+    if not is_node(name, node1):
+        return ChangeSet()
+    if not is_node(name, node2):
+        return ChangeSet()
+    if node1 == node2:
+        return ChangeSet()
+
+    sql = f"insert into pumps (id, node1, node2) values ('{id}', '{node1}', '{node2}');"
+    undo_sql = f'delete from pumps where id = "{id}";'
+    return add_link(name, PUMP, id, sql, undo_sql)
+
+
+def _get_pump(name: str, id: str) -> Row | None:
+    return query(name, f"select node1, node2 from pumps where id = '{id}'")
+
+
+def delete_pump(name: str, id: str) -> ChangeSet:
+    if not is_pump(name, id):
+        return ChangeSet()
+
+    row = _get_pump(name, id)
+    if row == None:
+        return ChangeSet()
+
+    node1, node2 = row['node1'], row['node2']
+
+    sql = f"delete from pumps where id = '{id}';"
+    undo_sql = f'insert into pumps (id, node1, node2) values ("{id}", "{node1}", "{node2}");'
+
+    return delete_link(name, PUMP, id, sql, undo_sql)
+
+
+def get_pump_node1(name: str, id: str) -> str | None:
+    row = _get_pump(name, id)
+    return row['node1'] if row != None else None
+
+
+def get_pump_node2(name: str, id: str) -> str | None:
+    row = _get_pump(name, id)
+    return row['node2'] if row != None else None
+
+
+def get_pump_power(name: str, id: str) -> str | None: pass
+def get_pump_speed(name: str, id: str) -> str | None: pass
+def get_pump_head(name: str, id: str) -> str | None: pass
+def get_pump_pattern(name: str, id: str) -> str | None: pass
+
+
+def _set_pump(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
+    if not is_pump(name, id):
+        return ChangeSet()
+
+    row = _get_pump(name, id)
+    if row == None:
+        return ChangeSet()
+
+    return update(name, PUMP, 'pumps', 'id', id, key, key_type, row[key], value, optional)
+
+
+def set_pump_node1(name: str, id: str, node1: str) -> ChangeSet:
+    if not is_node(name, node1):
+        return ChangeSet()
+    if get_pump_node2(name, id) == node1:
+        return ChangeSet()
+
+    return _set_pump(name, id, 'node1', 'str', str(node1))
+
+
+def set_pump_node2(name: str, id: str, node2: str) -> ChangeSet:
+    if not is_node(name, node2):
+        return ChangeSet()
+    if get_pump_node1(name, id) == node2:
+        return ChangeSet()
+
+    return _set_pump(name, id, 'node2', 'str', str(node2))
+
+
+def set_pump_power(name: str, id: str) -> ChangeSet: pass
+def set_pump_speed(name: str, id: str) -> ChangeSet: pass
+def set_pump_head(name: str, id: str) -> ChangeSet: pass
+def set_pump_pattern(name: str, id: str) -> ChangeSet: pass

api/s7_valves.py

@@ -0,0 +1,125 @@
+from psycopg.rows import Row
+from .s0_base import *
+from .change_set import ChangeSet
+from .utility import *
+
+
+VALVES_TYPE_PRV = 'prv'
+VALVES_TYPE_PSV = 'psv'
+VALVES_TYPE_PBV = 'pbv'
+VALVES_TYPE_FCV = 'fcv'
+VALVES_TYPE_TCV = 'tcv'
+VALVES_TYPE_GPV = 'gpv'
+
+
+def add_valve(name: str, id: str, node1: str, node2: str, diameter: float = 0, type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
+    if not is_node(name, node1):
+        return ChangeSet()
+    if not is_node(name, node2):
+        return ChangeSet()
+    if node1 == node2:
+        return ChangeSet()
+    if type != VALVES_TYPE_PRV and type != VALVES_TYPE_PSV and type != VALVES_TYPE_PBV and type != VALVES_TYPE_FCV and type != VALVES_TYPE_TCV and type != VALVES_TYPE_GPV:
+        return ChangeSet()
+
+    sql = f"insert into valves (id, node1, node2, diameter, type, setting, minor_loss) values ('{id}', '{node1}', '{node2}', {diameter}, '{type}', {setting}, {minor_loss});"
+    undo_sql = f'delete from valves where id = "{id}";'
+    return add_link(name, VALVE, id, sql, undo_sql)
+
+
+def _get_valve(name: str, id: str) -> Row | None:
+    return query(name, f"select node1, node2, diameter, type, setting, minor_loss from valves where id = '{id}'")
+
+
+def delete_valve(name: str, id: str) -> ChangeSet:
+    if not is_valve(name, id):
+        return ChangeSet()
+
+    row = _get_valve(name, id)
+    if row == None:
+        return ChangeSet()
+
+    node1, node2, diameter, type, setting, minor_loss = row['node1'], row['node2'], row['diameter'], row['type'], row['setting'], row['minor_loss']
+
+    sql = f"delete from valves where id = '{id}';"
+    undo_sql = f'insert into valves (id, node1, node2, diameter, type, setting, minor_loss) values ("{id}", "{node1}", "{node2}", {diameter}, "{type}", {setting}, {minor_loss});'
+
+    return delete_link(name, VALVE, id, sql, undo_sql)
+
+
+def get_valve_node1(name: str, id: str) -> str | None:
+    row = _get_valve(name, id)
+    return row['node1'] if row != None else None
+
+
+def get_valve_node2(name: str, id: str) -> str | None:
+    row = _get_valve(name, id)
+    return row['node2'] if row != None else None
+
+
+def get_valve_diameter(name: str, id: str) -> float | None:
+    row = _get_valve(name, id)
+    return float(row['diameter']) if row != None else None
+
+
+def get_valve_type(name: str, id: str) -> str | None:
+    row = _get_valve(name, id)
+    return row['type'] if row != None else None
+
+
+def get_valve_setting(name: str, id: str) -> float | None:
+    row = _get_valve(name, id)
+    return float(row['setting']) if row != None else None
+
+
+def get_valve_minor_loss(name: str, id: str) -> float | None:
+    row = _get_valve(name, id)
+    return float(row['minor_loss']) if row != None else None
+
+
+def _set_valve(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
+    if not is_valve(name, id):
+        return ChangeSet()
+
+    row = _get_valve(name, id)
+    if row == None:
+        return ChangeSet()
+
+    return update(name, VALVE, 'valves', 'id', id, key, key_type, row[key], value, optional)
+
+
+def set_valve_node1(name: str, id: str, node1: str) -> ChangeSet:
+    if not is_node(name, node1):
+        return ChangeSet()
+    if get_valve_node2(name, id) == node1:
+        return ChangeSet()
+
+    return _set_valve(name, id, 'node1', 'str', str(node1))
+
+
+def set_valve_node2(name: str, id: str, node2: str) -> ChangeSet:
+    if not is_node(name, node2):
+        return ChangeSet()
+    if get_valve_node1(name, id) == node2:
+        return ChangeSet()
+
+    return _set_valve(name, id, 'node2', 'str', str(node2))
+
+
+def set_valve_diameter(name: str, id: str, diameter: float) -> ChangeSet:
+    return _set_valve(name, id, 'diameter', 'float', str(diameter))
+
+
+def set_valve_type(name: str, id: str, type: str) -> ChangeSet:
+    if type != VALVES_TYPE_PRV and type != VALVES_TYPE_PSV and type != VALVES_TYPE_PBV and type != VALVES_TYPE_FCV and type != VALVES_TYPE_TCV and type != VALVES_TYPE_GPV:
+        return ChangeSet()
+
+    return _set_valve(name, id, 'type', 'str', type)
+
+
+def set_valve_setting(name: str, id: str, setting: float) -> ChangeSet:
+    return _set_valve(name, id, 'setting', 'float', str(setting))
+
+
+def set_valve_minor_loss(name: str, id: str, minor_loss: float) -> ChangeSet:
+    return _set_valve(name, id, 'minor_loss', 'float', str(minor_loss))

api/utility.py

@@ -0,0 +1,34 @@
+from psycopg.rows import dict_row, Row
+from .connection import g_conn_dict as conn
+from .operation import *
+from .change_set import ChangeSet
+
+
+def query(name: str, sql: str) -> Row | None:
+    with conn[name].cursor(row_factory=dict_row) as cur:
+        cur.execute(sql)
+        return cur.fetchone()
+
+
+def decorate(value: str | None, type: str, optional: bool) -> str:
+    if optional:
+        value = 'NULL' if value == None else value
+        if type == 'str':
+            value = f'"{value}"' if value != 'NULL' else value
+    return value
+
+
+def update(name: str, type: str, table: str, id_key: str, id_value: str, key: str, key_type: str, raw_old_value: str, value: str, optional: bool = False) -> ChangeSet:
+    value = f"'{value}'" if key_type is 'str' else value
+    old = decorate(raw_old_value, key_type, optional)
+
+    with conn[name].cursor() as cur:
+        sql = f"update {table} set {key} = {value} where {id_key} = '{id_value}'"
+        cur.execute(sql)
+        redo = sql.replace("'", '"')
+        undo = f'update {table} set {key} = {old} where {id_key} = "{id_value}"'
+        add_operation(name, redo, undo)
+
+    change = ChangeSet()
+    change.update(type, id_value, key, key_type, value)
+    return change

script/sql/create/0.base.sql

@@ -1,6 +1,6 @@
-CREATE TYPE _NODE_TYPE AS ENUM ('JUNCTION', 'RESERVOIR', 'TANK');
+CREATE TYPE _NODE_TYPE AS ENUM ('junction', 'reservoir', 'tank');
 
-CREATE TYPE _LINK_TYPE AS ENUM ('PIPE', 'PUMP', 'VALVE');
+CREATE TYPE _LINK_TYPE AS ENUM ('pipe', 'pump', 'valve');
 
 CREATE TABLE _NODE
 (

script/sql/create/13.controls.sql

@@ -25,6 +25,6 @@ CREATE TABLE CONTROLS_3
 (
   LinkID VARCHAR(32) PRIMARY KEY REFERENCES _LINK(ID)
 , Status TEXT NOT NULL -- OPEN / CLOSED, a pump speed setting, or a control valve setting
-, ClockTimeHour INTERVAL HOUR -- get AM/PM from it
+, Clock_Time_Hour INTERVAL HOUR -- get AM/PM from it
-, ClockTimeMin  INTERVAL MINUTE
+, Clock_Time_Min  INTERVAL MINUTE
 );

script/sql/create/18.sources.sql

@@ -7,5 +7,5 @@ CREATE TABLE SOURCES
   Node VARCHAR(32) PRIMARY KEY REFERENCES _NODE(ID)
 , Type SOURCES_TYPE NOT NULL
 , Strength NUMERIC NOT NULL
-, TimePattern VARCHAR(32) REFERENCES _PATTERN(ID)
+, Time_Pattern VARCHAR(32) REFERENCES _PATTERN(ID)
 );

script/sql/create/4.tanks.sql

@@ -1,16 +1,16 @@
 -- [TANKS]
 
-CREATE TYPE TANKS_OVERFLOW AS ENUM ('YES', 'NO');
+CREATE TYPE TANKS_OVERFLOW AS ENUM ('yes', 'no');
 
 CREATE TABLE TANKS
 (
   ID VARCHAR(32) PRIMARY KEY REFERENCES _NODE(ID)
 , Elevation NUMERIC NOT NULL
-, InitLevel NUMERIC NOT NULL
+, Init_Level NUMERIC NOT NULL
-, MinLevel NUMERIC NOT NULL
+, Min_Level NUMERIC NOT NULL
-, MaxLevel NUMERIC NOT NULL
+, Max_Level NUMERIC NOT NULL
 , Diameter NUMERIC NOT NULL
-, MinVol NUMERIC NOT NULL
+, Min_Vol NUMERIC NOT NULL
-, VolCurve VARCHAR(32) REFERENCES _CURVE(ID)
+, Vol_Curve VARCHAR(32) REFERENCES _CURVE(ID)
 , Overflow TANKS_OVERFLOW
 );

script/sql/create/5.pipes.sql

@@ -1,6 +1,6 @@
 -- [PIPES]
 
-CREATE TYPE PIPES_STATUS AS ENUM ('OPEN', 'CLOSED', 'CV');
+CREATE TYPE PIPES_STATUS AS ENUM ('open', 'closed', 'cv');
 
 CREATE TABLE PIPES
 (
@@ -10,6 +10,6 @@ CREATE TABLE PIPES
 , Length NUMERIC NOT NULL
 , Diameter NUMERIC NOT NULL
 , Roughness NUMERIC NOT NULL
-, MinorLoss NUMERIC NOT NULL
+, Minor_Loss NUMERIC NOT NULL
 , Status PIPES_STATUS NOT NULL
 );

script/sql/create/7.valves.sql

@@ -1,6 +1,6 @@
 -- [VALVES]
 
-CREATE TYPE VALVES_TYPE AS ENUM ('PRV', 'PSV', 'PBV', 'FCV', 'TCV', 'GPV');
+CREATE TYPE VALVES_TYPE AS ENUM ('prv', 'psv', 'pbv', 'fcv', 'tcv', 'gpv');
 
 CREATE TABLE VALVES
 (
@@ -10,5 +10,5 @@ CREATE TABLE VALVES
 , Diameter NUMERIC NOT NULL
 , Type VALVES_TYPE NOT NULL
 , Setting NUMERIC NOT NULL
-, MinorLoss NUMERIC NOT NULL
+, Minor_Loss NUMERIC NOT NULL
 );

script/template.py

@@ -67,10 +67,10 @@ sql_drop = [
 ]
 
 def create_template():
-    with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:
+    with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute("create database project")
-    with pg.connect(conninfo="dbname=project") as conn:
+    with pg.connect(conninfo="dbname=project host=127.0.0.1") as conn:
         with conn.cursor() as cur:
             for sql in sql_create:
                 with open(sql, "r") as f:
@@ -79,20 +79,20 @@ def create_template():
         conn.commit()
 
 def have_template():
-    with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:
+    with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute("select * from pg_database where datname = 'project'")
             return cur.rowcount > 0
 
 def delete_template():
-    with pg.connect(conninfo="dbname=project") as conn:
+    with pg.connect(conninfo="dbname=project host=127.0.0.1") as conn:
         with conn.cursor() as cur:
             for sql in sql_drop:
                 with open(sql, "r") as f:
                     cur.execute(f.read())
                 print(f'executed {sql}')
         conn.commit()
-    with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:
+    with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute("drop database project")
 

test_tjnetwork.py

@@ -0,0 +1,577 @@
+import pytest
+from tjnetwork import *
+
+class TestApi:
+    def enter(self, p):
+        if is_project_open(p):
+            close_project(p)
+
+        if have_project(p):
+            delete_project(p)
+
+        create_project(p)
+        open_project(p)
+
+    def leave(self, p):
+        close_project(p)
+        delete_project(p)
+
+    def test_title(self):
+        p = "test_title"
+        self.enter(p)
+
+        assert get_title(p) == ""
+
+        set_title(p, "title")
+        assert get_title(p) == "title"
+
+        set_title(p, "test")
+        assert get_title(p) == "test"
+
+        self.leave(p)
+
+    def test_junction(self):
+        p = "test_junction"
+        self.enter(p)
+
+        change_set = add_junction(p, "j0", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == JUNCTION
+        assert change_set.added[0]['id'] == "j0"
+        coord = get_junction_coord(p, 'j0')
+        assert coord['x'] == 0.0
+        assert coord['y'] == 10.0
+        z = get_junction_elevation(p, 'j0')
+        assert z == 20.0
+
+        assert get_junction_demand(p, 'j') == None
+        assert get_junction_demand(p, 'j0') == "NULL"
+        change_set = set_junction_demand(p, 'j0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == JUNCTION
+        assert change_set.updated[0]['id'] == 'j0'
+        assert change_set.updated[0]['property'] == 'demand'
+        assert change_set.updated[0]['property_type'] == 'float'
+        assert change_set.updated[0]['property_value'] == str(100.0)
+        assert get_junction_demand(p, 'j0') == 100.0
+
+        # TODO: pattern
+
+        change_set = add_junction(p, "j1", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == JUNCTION
+        assert change_set.added[0]['id'] == "j1"
+
+        change_set = add_junction(p, "j1", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 0
+
+        nodes = get_nodes(p)
+        assert len(nodes) == 2
+        assert nodes[0] == "j0"
+        assert nodes[1] == "j1"
+
+        change_set = delete_junction(p, 'j1')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == JUNCTION
+        assert change_set.deleted[0]['id'] == "j1"
+
+        change_set = delete_junction(p, 'j1')
+        assert len(change_set.deleted) == 0
+
+        nodes = get_nodes(p)
+        assert len(nodes) == 1
+        assert nodes[0] == "j0"
+
+        change_set = delete_junction(p, 'j0')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == JUNCTION
+        assert change_set.deleted[0]['id'] == "j0"
+
+        nodes = get_nodes(p)
+        assert len(nodes) == 0
+
+        self.leave(p)
+
+    def test_reservoir(self):
+        p = "test_reservoir"
+        self.enter(p)
+
+        change_set = add_reservoir(p, "r0", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == RESERVOIR
+        assert change_set.added[0]['id'] == "r0"
+
+        change_set = add_reservoir(p, "r0", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 0
+
+        assert get_reservoir_head(p, 'r0') == 20.0
+        change_set = set_reservoir_head(p, 'r0', 100.0)
+        assert change_set.updated[0]['type'] == RESERVOIR
+        assert change_set.updated[0]['id'] == 'r0'
+        assert change_set.updated[0]['property'] == 'head'
+        assert change_set.updated[0]['property_type'] == 'float'
+        assert change_set.updated[0]['property_value'] == str(100.0)
+        assert get_reservoir_head(p, 'r0') == 100.0
+
+        assert get_reservoir_coord(p, 'r0') == { 'x': 0.0, 'y': 10.0 }
+        change_set = set_reservoir_coord(p, 'r0', 100.0, 200.0)
+        assert change_set.updated[0]['type'] == RESERVOIR
+        assert change_set.updated[0]['id'] == 'r0'
+        assert change_set.updated[0]['property'] == 'coord'
+        assert change_set.updated[0]['property_type'] == 'point'
+        assert change_set.updated[0]['property_value'] == str({'x': 100.0, 'y': 200.0})
+        assert get_reservoir_coord(p, 'r0') == { 'x': 100.0, 'y': 200.0 }
+
+        # TODO: pattern
+
+        change_set = delete_reservoir(p, 'r0')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == RESERVOIR
+        assert change_set.deleted[0]['id'] == "r0"
+
+        change_set = delete_reservoir(p, 'r0')
+        assert len(change_set.deleted) == 0
+
+        self.leave(p)
+
+    def test_tank(self):
+        p = "test_tank"
+
+        self.enter(p)
+
+        change_set = add_tank(p, "t0", 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == TANK
+        assert change_set.added[0]['id'] == "t0"
+
+        change_set = add_tank(p, "t1", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == TANK
+        assert change_set.added[0]['id'] == "t1"
+
+        change_set = add_tank(p, "t1", 0.0, 10.0, 20.0)
+        assert len(change_set.added) == 0
+
+        tanks = get_nodes(p)
+        assert len(tanks) == 2
+        assert tanks[0] == 't0'
+        assert tanks[1] == 't1'
+
+        assert get_tank_elevation(p, 't0') == 10.0
+        change_set = set_tank_elevation(p, 't0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'elevation'
+        assert get_tank_elevation(p, 't0') == 100.0
+
+        assert get_tank_init_level(p, 't0') == 10.0
+        change_set = set_tank_init_level(p, 't0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'init_level'
+        assert get_tank_init_level(p, 't0') == 100.0
+
+        assert get_tank_min_level(p, 't0') == 10.0
+        change_set = set_tank_min_level(p, 't0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'min_level'
+        assert get_tank_min_level(p, 't0') == 100.0
+
+        assert get_tank_max_level(p, 't0') == 10.0
+        change_set = set_tank_max_level(p, 't0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'max_level'
+        assert get_tank_max_level(p, 't0') == 100.0
+
+        assert get_tank_diameter(p, 't0') == 10.0
+        change_set = set_tank_diameter(p, 't0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'diameter'
+        assert get_tank_diameter(p, 't0') == 100.0
+
+        assert get_tank_min_vol(p, 't0') == 10.0
+        change_set = set_tank_min_vol(p, 't0', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'min_vol'
+        assert get_tank_min_vol(p, 't0') == 100.0
+
+        # TODO: vol_curve
+
+        assert get_tank_overflow(p, 't') == None
+        assert get_tank_overflow(p, 't0') == 'NULL'
+        change_set = set_tank_overflow(p, 't0', "XXX")
+        assert len(change_set.updated) == 0
+        change_set = set_tank_overflow(p, 't0', OVERFLOW_YES)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == TANK
+        assert change_set.updated[0]['id'] == "t0"
+        assert change_set.updated[0]['property'] == 'overflow'
+        assert get_tank_overflow(p, 't0') == OVERFLOW_YES
+
+        change_set = delete_tank(p, "t0")
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == TANK
+        assert change_set.deleted[0]['id'] == "t0"
+
+        tanks = get_nodes(p)
+        assert len(tanks) == 1
+
+        change_set = delete_tank(p, "t1")
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == TANK
+        assert change_set.deleted[0]['id'] == "t1"
+
+        change_set = delete_tank(p, "t1")
+        assert len(change_set.deleted) == 0
+
+        tanks = get_nodes(p)
+        assert len(tanks) == 0
+
+        self.leave(p)
+
+    def test_pipe(self):
+        p = "test_pipe"
+        self.enter(p)
+
+        change_set = add_pipe(p, 'p1', 'j1', 'j2', 10.0, 10.0, 10.0, 10.0, PIPE_STATUS_CLOSED)
+        assert len(change_set.added) == 0
+
+        add_junction(p, 'j1', 0.0, 0.0, 0.0)
+        add_junction(p, 'j2', 10.0, 10.0, 0.0)
+        add_junction(p, 'j3', 0.0, 0.0, 0.0)
+        add_junction(p, 'j4', 10.0, 10.0, 0.0)
+        assert is_junction(p, 'j1')
+        assert is_junction(p, 'j2')
+        assert is_junction(p, 'j3')
+        assert is_junction(p, 'j4')
+
+        assert not is_link(p, 'p1')
+
+        change_set = add_pipe(p, 'p1', 'j1', 'j2', 10.0, 10.0, 10.0, 10.0, "XXX")
+        assert len(change_set.added) == 0
+
+        change_set = add_pipe(p, 'p1', 'j1', 'j1', 10.0, 10.0, 10.0, 10.0, PIPE_STATUS_CLOSED)
+        assert len(change_set.added) == 0
+
+        change_set = add_pipe(p, 'p1', 'j1', 'j2', 10.0, 10.0, 10.0, 10.0, PIPE_STATUS_CLOSED)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == PIPE
+        assert change_set.added[0]['id'] == "p1"
+
+        change_set = add_pipe(p, 'p1', 'j1', 'j2', 10.0, 10.0, 10.0, 10.0, PIPE_STATUS_CLOSED)
+        assert len(change_set.added) == 0
+
+        pipes = get_links(p)
+        assert len(pipes) == 1
+
+        assert get_pipe_node1(p, 'p1') == 'j1'
+        assert get_pipe_node2(p, 'p1') == 'j2'
+        assert get_pipe_length(p, 'p1') == 10.0
+        assert get_pipe_diameter(p, 'p1') == 10.0
+        assert get_pipe_roughness(p, 'p1') == 10.0
+        assert get_pipe_minor_loss(p, 'p1') == 10.0
+        assert get_pipe_status(p, 'p1') == PIPE_STATUS_CLOSED
+
+        change_set = set_pipe_node1(p, 'p1', 'j2')
+        assert len(change_set.updated) == 0
+        change_set = set_pipe_node2(p, 'p1', 'j1')
+        assert len(change_set.updated) == 0
+        change_set = set_pipe_status(p, 'p1', "XXX")
+        assert len(change_set.updated) == 0
+
+        change_set = set_pipe_node1(p, 'p1', 'j3')
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'node1'
+
+        change_set = set_pipe_node2(p, 'p1', 'j4')
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'node2'
+
+        change_set = set_pipe_length(p, 'p1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'length'
+
+        change_set = set_pipe_diameter(p, 'p1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'diameter'
+
+        change_set = set_pipe_roughness(p, 'p1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'roughness'
+
+        change_set = set_pipe_minor_loss(p, 'p1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'minor_loss'
+
+        change_set = set_pipe_status(p, 'p1', PIPE_STATUS_OPEN)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PIPE
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'status'
+
+        assert get_pipe_node1(p, 'p1') == 'j3'
+        assert get_pipe_node2(p, 'p1') == 'j4'
+        assert get_pipe_length(p, 'p1') == 100.0
+        assert get_pipe_diameter(p, 'p1') == 100.0
+        assert get_pipe_roughness(p, 'p1') == 100.0
+        assert get_pipe_minor_loss(p, 'p1') == 100.0
+        assert get_pipe_status(p, 'p1') == PIPE_STATUS_OPEN
+
+        change_set = add_pipe(p, 'p2', 'j1', 'j2', 10.0, 10.0, 10.0, 10.0, PIPE_STATUS_CLOSED)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == PIPE
+        assert change_set.added[0]['id'] == "p2"
+
+        pipes = get_links(p)
+        assert len(pipes) == 2
+
+        change_set = delete_pipe(p, 'p')
+        assert len(change_set.deleted) == 0
+
+        assert is_pipe(p, 'p1')
+
+        change_set = delete_pipe(p, 'p1')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == PIPE
+        assert change_set.deleted[0]['id'] == "p1"
+
+        pipes = get_links(p)
+        assert len(pipes) == 1
+
+        change_set = delete_pipe(p, 'p2')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == PIPE
+        assert change_set.deleted[0]['id'] == "p2"
+
+        self.leave(p)
+
+    def test_pump(self):
+        p = "test_pump"
+        self.enter(p)
+
+        change_set = add_pump(p, 'p1', 'j1', 'j2')
+        assert len(change_set.added) == 0
+
+        add_junction(p, 'j1', 0.0, 0.0, 0.0)
+        add_junction(p, 'j2', 10.0, 10.0, 0.0)
+        add_junction(p, 'j3', 0.0, 0.0, 0.0)
+        add_junction(p, 'j4', 10.0, 10.0, 0.0)
+        assert is_junction(p, 'j1')
+        assert is_junction(p, 'j2')
+        assert is_junction(p, 'j3')
+        assert is_junction(p, 'j4')
+
+        assert not is_link(p, 'p1')
+
+        change_set = add_pump(p, 'p1', 'j1', 'j1')
+        assert len(change_set.added) == 0
+
+        change_set = add_pump(p, 'p1', 'j1', 'j2')
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == PUMP
+        assert change_set.added[0]['id'] == "p1"
+
+        change_set = add_pump(p, 'p1', 'j1', 'j2')
+        assert len(change_set.added) == 0
+
+        pumps = get_links(p)
+        assert len(pumps) == 1
+
+        assert get_pump_node1(p, 'p1') == 'j1'
+        assert get_pump_node2(p, 'p1') == 'j2'
+
+        change_set = set_pump_node1(p, 'p1', 'j2')
+        assert len(change_set.updated) == 0
+        change_set = set_pump_node2(p, 'p1', 'j1')
+        assert len(change_set.updated) == 0
+
+        change_set = set_pump_node1(p, 'p1', 'j3')
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PUMP
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'node1'
+
+        change_set = set_pump_node2(p, 'p1', 'j4')
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == PUMP
+        assert change_set.updated[0]['id'] == 'p1'
+        assert change_set.updated[0]['property'] == 'node2'
+
+        assert get_pump_node1(p, 'p1') == 'j3'
+        assert get_pump_node2(p, 'p1') == 'j4'
+
+        change_set = add_pump(p, 'p2', 'j1', 'j2')
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == PUMP
+        assert change_set.added[0]['id'] == "p2"
+
+        pumps = get_links(p)
+        assert len(pumps) == 2
+
+        change_set = delete_pump(p, 'p')
+        assert len(change_set.deleted) == 0
+
+        assert is_pump(p, 'p1')
+
+        change_set = delete_pump(p, 'p1')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == PUMP
+        assert change_set.deleted[0]['id'] == "p1"
+
+        pumps = get_links(p)
+        assert len(pumps) == 1
+
+        change_set = delete_pump(p, 'p2')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == PUMP
+        assert change_set.deleted[0]['id'] == "p2"
+
+        self.leave(p)
+
+    def test_valve(self):
+        p = "test_valve"
+        self.enter(p)
+
+        change_set = add_valve(p, 'v1', 'j1', 'j2', 10.0, VALVES_TYPE_FCV, 10.0, 10.0)
+        assert len(change_set.added) == 0
+
+        add_junction(p, 'j1', 0.0, 0.0, 0.0)
+        add_junction(p, 'j2', 10.0, 10.0, 0.0)
+        add_junction(p, 'j3', 0.0, 0.0, 0.0)
+        add_junction(p, 'j4', 10.0, 10.0, 0.0)
+        assert is_junction(p, 'j1')
+        assert is_junction(p, 'j2')
+        assert is_junction(p, 'j3')
+        assert is_junction(p, 'j4')
+
+        assert not is_link(p, 'v1')
+
+        change_set = add_valve(p, 'v1', 'j1', 'j2', 10.0, "xxx", 10.0, 10.0)
+        assert len(change_set.added) == 0
+
+        change_set = add_valve(p, 'v1', 'j1', 'j1', 10.0, VALVES_TYPE_FCV, 10.0, 10.0)
+        assert len(change_set.added) == 0
+
+        change_set = add_valve(p, 'v1', 'j1', 'j2', 10.0, VALVES_TYPE_FCV, 10.0, 10.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == VALVE
+        assert change_set.added[0]['id'] == "v1"
+
+        change_set = add_valve(p, 'v1', 'j1', 'j2', 10.0, VALVES_TYPE_FCV, 10.0, 10.0)
+        assert len(change_set.added) == 0
+
+        valves = get_links(p)
+        assert len(valves) == 1
+
+        assert get_valve_node1(p, 'v1') == 'j1'
+        assert get_valve_node2(p, 'v1') == 'j2'
+        assert get_valve_diameter(p, 'v1') == 10.0
+        assert get_valve_type(p, 'v1') == VALVES_TYPE_FCV
+        assert get_valve_setting(p, 'v1') == 10.0
+        assert get_valve_minor_loss(p, 'v1') == 10.0
+
+        change_set = set_valve_node1(p, 'v1', 'j2')
+        assert len(change_set.updated) == 0
+        change_set = set_valve_node2(p, 'v1', 'j1')
+        assert len(change_set.updated) == 0
+        change_set = set_valve_type(p, 'v1', "XXX")
+        assert len(change_set.updated) == 0
+
+        change_set = set_valve_node1(p, 'v1', 'j3')
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == VALVE
+        assert change_set.updated[0]['id'] == 'v1'
+        assert change_set.updated[0]['property'] == 'node1'
+
+        change_set = set_valve_node2(p, 'v1', 'j4')
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == VALVE
+        assert change_set.updated[0]['id'] == 'v1'
+        assert change_set.updated[0]['property'] == 'node2'
+
+        change_set = set_valve_diameter(p, 'v1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == VALVE
+        assert change_set.updated[0]['id'] == 'v1'
+        assert change_set.updated[0]['property'] == 'diameter'
+
+        change_set = set_valve_type(p, 'v1', VALVES_TYPE_GPV)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == VALVE
+        assert change_set.updated[0]['id'] == 'v1'
+        assert change_set.updated[0]['property'] == 'type'
+
+        change_set = set_valve_setting(p, 'v1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == VALVE
+        assert change_set.updated[0]['id'] == 'v1'
+        assert change_set.updated[0]['property'] == 'setting'
+
+        change_set = set_valve_minor_loss(p, 'v1', 100.0)
+        assert len(change_set.updated) == 1
+        assert change_set.updated[0]['type'] == VALVE
+        assert change_set.updated[0]['id'] == 'v1'
+        assert change_set.updated[0]['property'] == 'minor_loss'
+
+        assert get_valve_node1(p, 'v1') == 'j3'
+        assert get_valve_node2(p, 'v1') == 'j4'
+        assert get_valve_diameter(p, 'v1') == 100.0
+        assert get_valve_type(p, 'v1') == VALVES_TYPE_GPV
+        assert get_valve_setting(p, 'v1') == 100.0
+        assert get_valve_minor_loss(p, 'v1') == 100.0
+
+        change_set = add_valve(p, 'v2', 'j1', 'j2', 10.0, VALVES_TYPE_FCV, 10.0, 10.0)
+        assert len(change_set.added) == 1
+        assert change_set.added[0]['type'] == VALVE
+        assert change_set.added[0]['id'] == "v2"
+
+        valves = get_links(p)
+        assert len(valves) == 2
+
+        change_set = delete_valve(p, 'v')
+        assert len(change_set.deleted) == 0
+
+        assert is_valve(p, 'v1')
+
+        change_set = delete_valve(p, 'v1')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == VALVE
+        assert change_set.deleted[0]['id'] == "v1"
+
+        valves = get_links(p)
+        assert len(valves) == 1
+
+        change_set = delete_valve(p, 'v2')
+        assert len(change_set.deleted) == 1
+        assert change_set.deleted[0]['type'] == VALVE
+        assert change_set.deleted[0]['id'] == "v2"
+
+        self.leave(p)
+
+    def test_coordinate(self):
+        pass
+
+if __name__ == '__main__':
+    pytest.main()

tjnetwork.py

@@ -19,6 +19,20 @@ PIPE = api.PIPE
 PUMP = api.PUMP
 VALVE = api.VALVE
 
+OVERFLOW_YES = api.OVERFLOW_YES
+OVERFLOW_NO = api.OVERFLOW_NO
+
+PIPE_STATUS_OPEN = api.PIPE_STATUS_OPEN
+PIPE_STATUS_CLOSED = api.PIPE_STATUS_CLOSED
+PIPE_STATUS_CV = api.PIPE_STATUS_CV
+
+VALVES_TYPE_PRV = api.VALVES_TYPE_PRV
+VALVES_TYPE_PSV = api.VALVES_TYPE_PSV
+VALVES_TYPE_PBV = api.VALVES_TYPE_PBV
+VALVES_TYPE_FCV = api.VALVES_TYPE_FCV
+VALVES_TYPE_TCV = api.VALVES_TYPE_TCV
+VALVES_TYPE_GPV = api.VALVES_TYPE_GPV
+
 
 ############################################################
 # project
@@ -169,3 +183,220 @@ def set_junction_pattern(name: str, junction_id: str, pattern: str) -> ChangeSet
 
 def set_junction_coord(name: str, junction_id: str, x: float, y: float) -> ChangeSet:
     return api.set_junction_coord(name, junction_id, x, y)
+
+
+############################################################
+# reservoir 3.[RESERVOIRS]
+############################################################
+
+def add_reservoir(name: str, reservoir_id: str, x: float, y: float, head: float) -> ChangeSet:
+    return api.add_reservoir(name, reservoir_id, x, y, head)
+
+def delete_reservoir(name: str, reservoir_id: str) -> ChangeSet:
+    return api.delete_reservoir(name, reservoir_id)
+
+def get_reservoir_head(name: str, reservoir_id: str) -> float | None:
+    return api.get_reservoir_head(name, reservoir_id)
+
+def get_reservoir_pattern(name: str, reservoir_id: str) -> str | None:
+    return api.get_reservoir_pattern(name, reservoir_id)
+
+def get_reservoir_coord(name: str, reservoir_id: str) -> dict[str, float] | None:
+    return api.get_reservoir_coord(name, reservoir_id)
+
+def set_reservoir_head(name: str, reservoir_id: str, head: float) -> ChangeSet:
+    return api.set_reservoir_head(name, reservoir_id, head)
+
+def set_reservoir_pattern(name: str, reservoir_id: str, pattern: str) -> ChangeSet:
+    return api.set_reservoir_pattern(name, reservoir_id, pattern)
+
+def set_reservoir_coord(name: str, reservoir_id: str, x: float, y: float) -> ChangeSet:
+    return api.set_reservoir_coord(name, reservoir_id, x, y)
+
+
+############################################################
+# tank 4.[TANKS]
+############################################################
+
+def add_tank(name: str, tank_id: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
+    return api.add_tank(name, tank_id, x, y, elevation, init_level, min_level, max_level, diameter, min_vol)
+
+def delete_tank(name: str, tank_id: str) -> ChangeSet:
+    return api.delete_tank(name, tank_id)
+
+def get_tank_elevation(name: str, tank_id: str) -> float | None:
+    return api.get_tank_elevation(name, tank_id)
+
+def get_tank_init_level(name: str, tank_id: str) -> float | None:
+    return api.get_tank_init_level(name, tank_id)
+
+def get_tank_min_level(name: str, tank_id: str) -> float | None:
+    return api.get_tank_min_level(name, tank_id)
+
+def get_tank_max_level(name: str, tank_id: str) -> float | None:
+    return api.get_tank_max_level(name, tank_id)
+
+def get_tank_diameter(name: str, tank_id: str) -> float | None:
+    return api.get_tank_diameter(name, tank_id)
+
+def get_tank_min_vol(name: str, tank_id: str) -> float | None:
+    return api.get_tank_min_vol(name, tank_id)
+
+def get_tank_vol_curve(name: str, tank_id: str) -> str | None:
+    return api.get_tank_vol_curve(name, tank_id)
+
+def get_tank_overflow(name: str, tank_id: str) -> str | None:
+    return api.get_tank_overflow(name, tank_id)
+
+def get_tank_coord(name: str, tank_id: str) -> dict[str, float] | None:
+    return api.get_tank_coord(name, tank_id)
+
+def set_tank_elevation(name: str, tank_id: str, elevation: float) -> ChangeSet:
+    return api.set_tank_elevation(name, tank_id, elevation)
+
+def set_tank_init_level(name: str, tank_id: str, init_level: float) -> ChangeSet:
+    return api.set_tank_init_level(name, tank_id, init_level)
+
+def set_tank_min_level(name: str, tank_id: str, min_level: float) -> ChangeSet:
+    return api.set_tank_min_level(name, tank_id, min_level)
+
+def set_tank_max_level(name: str, tank_id: str, max_level: float) -> ChangeSet:
+    return api.set_tank_max_level(name, tank_id, max_level)
+
+def set_tank_diameter(name: str, tank_id: str, diameter: float) -> ChangeSet:
+    return api.set_tank_diameter(name, tank_id, diameter)
+
+def set_tank_min_vol(name: str, tank_id: str, min_vol: float) -> ChangeSet:
+    return api.set_tank_min_vol(name, tank_id, min_vol)
+
+def set_tank_vol_curve(name: str, tank_id: str, vol_curve: str) -> ChangeSet:
+    return api.set_tank_vol_curve(name, tank_id, vol_curve)
+
+def set_tank_overflow(name: str, tank_id: str, overflow: str) -> ChangeSet:
+    return api.set_tank_overflow(name, tank_id, overflow)
+
+def set_tank_coord(name: str, tank_id: str, x: float, y: float) -> ChangeSet:
+    return api.set_tank_coord(name, tank_id, x, y)
+
+
+############################################################
+# pipe 4.[PIPES]
+############################################################
+
+def add_pipe(name: str, pipe_id: str, node1: str, node2: str, length: float = 0, diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
+    return api.add_pipe(name, pipe_id, node1, node2, length, diameter, roughness, minor_loss, status)
+
+def delete_pipe(name: str, pipe_id: str) -> ChangeSet:
+    return api.delete_pipe(name, pipe_id)
+
+def get_pipe_node1(name: str, pipe_id: str) -> str | None:
+    return api.get_pipe_node1(name, pipe_id)
+
+def get_pipe_node2(name: str, pipe_id: str) -> str | None:
+    return api.get_pipe_node2(name, pipe_id)
+
+def get_pipe_length(name: str, pipe_id: str) -> float | None:
+    return api.get_pipe_length(name, pipe_id)
+
+def get_pipe_diameter(name: str, pipe_id: str) -> float | None:
+    return api.get_pipe_diameter(name, pipe_id)
+
+def get_pipe_roughness(name: str, pipe_id: str) -> float | None:
+    return api.get_pipe_roughness(name, pipe_id)
+
+def get_pipe_minor_loss(name: str, pipe_id: str) -> float | None:
+    return api.get_pipe_minor_loss(name, pipe_id)
+
+def get_pipe_status(name: str, pipe_id: str) -> str | None:
+    return api.get_pipe_status(name, pipe_id)
+
+def set_pipe_node1(name: str, pipe_id: str, node1: str) -> ChangeSet:
+    return api.set_pipe_node1(name, pipe_id, node1)
+
+def set_pipe_node2(name: str, pipe_id: str, node2: str) -> ChangeSet:
+    return api.set_pipe_node2(name, pipe_id, node2)
+
+def set_pipe_length(name: str, pipe_id: str, length: float) -> ChangeSet:
+    return api.set_pipe_length(name, pipe_id, length)
+
+def set_pipe_diameter(name: str, pipe_id: str, diameter: float) -> ChangeSet:
+    return api.set_pipe_diameter(name, pipe_id, diameter)
+
+def set_pipe_roughness(name: str, pipe_id: str, roughness: float) -> ChangeSet:
+    return api.set_pipe_roughness(name, pipe_id, roughness)
+
+def set_pipe_minor_loss(name: str, pipe_id: str, minor_loss: float) -> ChangeSet:
+    return api.set_pipe_minor_loss(name, pipe_id, minor_loss)
+
+def set_pipe_status(name: str, pipe_id: str, status: float) -> ChangeSet:
+    return api.set_pipe_status(name, pipe_id, status)
+
+
+############################################################
+# pump 4.[PUMPS]
+############################################################
+
+def add_pump(name: str, pump_id: str, node1: str, node2: str) -> ChangeSet:
+    return api.add_pump(name, pump_id, node1, node2)
+
+def delete_pump(name: str, pump_id: str) -> ChangeSet:
+    return api.delete_pump(name, pump_id)
+
+def get_pump_node1(name: str, pump_id: str) -> str | None:
+    return api.get_pump_node1(name, pump_id)
+
+def get_pump_node2(name: str, pump_id: str) -> str | None:
+    return api.get_pump_node2(name, pump_id)
+
+def set_pump_node1(name: str, pump_id: str, node1: str) -> ChangeSet:
+    return api.set_pump_node1(name, pump_id, node1)
+
+def set_pump_node2(name: str, pump_id: str, node2: str) -> ChangeSet:
+    return api.set_pump_node2(name, pump_id, node2)
+
+
+############################################################
+# valve 4.[VALVES]
+############################################################
+
+def add_valve(name: str, valve_id: str, node1: str, node2: str, diameter: float = 0, type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
+    return api.add_valve(name, valve_id, node1, node2, diameter, type, setting, minor_loss)
+
+def delete_valve(name: str, valve_id: str) -> ChangeSet:
+    return api.delete_valve(name, valve_id)
+
+def get_valve_node1(name: str, valve_id: str) -> str | None:
+    return api.get_valve_node1(name, valve_id)
+
+def get_valve_node2(name: str, valve_id: str) -> str | None:
+    return api.get_valve_node2(name, valve_id)
+
+def get_valve_diameter(name: str, valve_id: str) -> float | None:
+    return api.get_valve_diameter(name, valve_id)
+
+def get_valve_type(name: str, valve_id: str) -> str | None:
+    return api.get_valve_type(name, valve_id)
+
+def get_valve_setting(name: str, valve_id: str) -> float | None:
+    return api.get_valve_setting(name, valve_id)
+
+def get_valve_minor_loss(name: str, valve_id: str) -> float | None:
+    return api.get_valve_minor_loss(name, valve_id)
+
+def set_valve_node1(name: str, valve_id: str, node1: str) -> ChangeSet:
+    return api.set_valve_node1(name, valve_id, node1)
+
+def set_valve_node2(name: str, valve_id: str, node2: str) -> ChangeSet:
+    return api.set_valve_node2(name, valve_id, node2)
+
+def set_valve_diameter(name: str, valve_id: str, diameter: float) -> ChangeSet:
+    return api.set_valve_diameter(name, valve_id, diameter)
+
+def set_valve_type(name: str, valve_id: str, type: str) -> ChangeSet:
+    return api.set_valve_type(name, valve_id, type)
+
+def set_valve_setting(name: str, valve_id: str, setting: float) -> ChangeSet:
+    return api.set_valve_setting(name, valve_id, setting)
+
+def set_valve_minor_loss(name: str, valve_id: str, minor_loss: float) -> ChangeSet:
+    return api.set_valve_minor_loss(name, valve_id, minor_loss)