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
This commit is contained in:
王琼钰
3
.gitignore
vendored
3
.gitignore
vendored
@@ -1,6 +1,9 @@
|
||||
# python cache
|
||||
__pycache__/
|
||||
|
||||
# pytest
|
||||
.pytest_cache/
|
||||
|
||||
# epanet
|
||||
*.rpt
|
||||
*.opt
|
||||
|
||||
@@ -20,4 +20,30 @@ 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 .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
|
||||
@@ -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
|
||||
|
||||
120
api/s0_base.py
120
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"
|
||||
RESERVOIR = "RESERVOIR"
|
||||
TANK = "TANK"
|
||||
PIPE = "PIPE"
|
||||
PUMP = "PUMP"
|
||||
VALVE = "VALVE"
|
||||
JUNCTION = "junction"
|
||||
RESERVOIR = "reservoir"
|
||||
TANK = "tank"
|
||||
PIPE = "pipe"
|
||||
PUMP = "pump"
|
||||
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
|
||||
|
||||
43
api/s24_coordinates.py
Normal file
43
api/s24_coordinates.py
Normal file
@@ -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
|
||||
@@ -1,77 +1,43 @@
|
||||
from psycopg.rows import dict_row, Row
|
||||
from .connection import g_conn_dict as conn
|
||||
from psycopg.rows import Row
|
||||
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):
|
||||
return
|
||||
sql = f"insert into junctions (id, elevation) values ('{id}', {elevation});"
|
||||
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("'", '"')
|
||||
undo = f'delete from coordinates where node = "{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 _get_junction(name: str, id: str) -> Row | None:
|
||||
return query(name, f"select elevation, demand, pattern from junctions where id = '{id}'")
|
||||
|
||||
|
||||
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:
|
||||
cur.execute(f"select * from junctions where id = '{id}'")
|
||||
row = cur.fetchone()
|
||||
if row == None:
|
||||
return
|
||||
row = _get_junction(name, id)
|
||||
if row == None:
|
||||
return ChangeSet()
|
||||
|
||||
elevation = row['elevation']
|
||||
demand = 'NULL' if row['demand'] == None else row['demand']
|
||||
pattern = 'NULL' if row['pattern'] == None else row['pattern']
|
||||
pattern = f'"{pattern}"' if pattern != 'NULL' else pattern
|
||||
elevation = row['elevation']
|
||||
demand = decorate(row['demand'], 'float', True)
|
||||
pattern = decorate(row['pattern'], 'str', True)
|
||||
|
||||
cur.execute(f"select * from coordinates where node = '{id}'")
|
||||
row = cur.fetchone()
|
||||
if row == None:
|
||||
return
|
||||
sql = f"delete from junctions where id = '{id}';"
|
||||
undo_sql = f'insert into junctions (id, elevation, demand, pattern) values ("{id}", {elevation}, {demand}, {pattern});'
|
||||
|
||||
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:
|
||||
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)
|
||||
return get_node_coord(name, id)
|
||||
|
||||
|
||||
def _set_junction(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
|
||||
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)
|
||||
|
||||
|
||||
def set_junction_elevation(name: str, id: str, elevation: float) -> ChangeSet:
|
||||
if not is_junction(name, id):
|
||||
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
|
||||
return _set_junction(name, id, 'elevation', 'float', str(elevation))
|
||||
|
||||
|
||||
def set_junction_demand(name: str, id: str, demand: float) -> ChangeSet:
|
||||
if not is_junction(name, id):
|
||||
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
|
||||
return _set_junction(name, id, 'demand', 'float', str(demand), True)
|
||||
|
||||
|
||||
def set_junction_pattern(name: str, id: str, pattern: str) -> ChangeSet:
|
||||
if not is_junction(name, id):
|
||||
return
|
||||
if not is_pattern(name, id):
|
||||
return
|
||||
if not is_pattern(name, pattern):
|
||||
return ChangeSet()
|
||||
|
||||
old = get_junction_pattern(name, id)
|
||||
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
|
||||
return _set_junction(name, id, 'pattern', 'str', pattern, True)
|
||||
|
||||
|
||||
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)
|
||||
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
|
||||
return set_node_coord(name, JUNCTION, id, x, y)
|
||||
|
||||
78
api/s3_reservoirs.py
Normal file
78
api/s3_reservoirs.py
Normal file
@@ -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)
|
||||
148
api/s4_tanks.py
Normal file
148
api/s4_tanks.py
Normal file
@@ -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)
|
||||
132
api/s5_pipes.py
Normal file
132
api/s5_pipes.py
Normal file
@@ -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))
|
||||
88
api/s6_pumps.py
Normal file
88
api/s6_pumps.py
Normal file
@@ -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
|
||||
125
api/s7_valves.py
Normal file
125
api/s7_valves.py
Normal file
@@ -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))
|
||||
34
api/utility.py
Normal file
34
api/utility.py
Normal file
@@ -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
|
||||
@@ -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
|
||||
(
|
||||
|
||||
@@ -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
|
||||
, ClockTimeMin INTERVAL MINUTE
|
||||
, Clock_Time_Hour INTERVAL HOUR -- get AM/PM from it
|
||||
, Clock_Time_Min INTERVAL MINUTE
|
||||
);
|
||||
|
||||
@@ -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)
|
||||
);
|
||||
|
||||
@@ -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
|
||||
, MinLevel NUMERIC NOT NULL
|
||||
, MaxLevel NUMERIC NOT NULL
|
||||
, Init_Level NUMERIC NOT NULL
|
||||
, Min_Level NUMERIC NOT NULL
|
||||
, Max_Level NUMERIC NOT NULL
|
||||
, Diameter NUMERIC NOT NULL
|
||||
, MinVol NUMERIC NOT NULL
|
||||
, VolCurve VARCHAR(32) REFERENCES _CURVE(ID)
|
||||
, Min_Vol NUMERIC NOT NULL
|
||||
, Vol_Curve VARCHAR(32) REFERENCES _CURVE(ID)
|
||||
, Overflow TANKS_OVERFLOW
|
||||
);
|
||||
|
||||
@@ -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
|
||||
);
|
||||
|
||||
@@ -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
|
||||
);
|
||||
|
||||
@@ -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")
|
||||
|
||||
|
||||
577
test_tjnetwork.py
Normal file
577
test_tjnetwork.py
Normal file
@@ -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()
|
||||
231
tjnetwork.py
231
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)
|
||||
|
||||
Reference in New Issue
Block a user