From 8ffb4ed720a482f4067b4f44c082428f7ae23b50 Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 22:41:11 +0800 Subject: [PATCH 01/46] Rename some field of table --- script/sql/create/13.controls.sql | 4 ++-- script/sql/create/18.sources.sql | 2 +- script/sql/create/4.tanks.sql | 10 +++++----- script/sql/create/5.pipes.sql | 2 +- script/sql/create/7.valves.sql | 2 +- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/script/sql/create/13.controls.sql b/script/sql/create/13.controls.sql index aa107eb..71e74da 100644 --- a/script/sql/create/13.controls.sql +++ b/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 -, ClockTimeMin INTERVAL MINUTE +, Clock_Time_Hour INTERVAL HOUR -- get AM/PM from it +, Clock_Time_Min INTERVAL MINUTE ); diff --git a/script/sql/create/18.sources.sql b/script/sql/create/18.sources.sql index 1c2ec64..08009f2 100644 --- a/script/sql/create/18.sources.sql +++ b/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) ); diff --git a/script/sql/create/4.tanks.sql b/script/sql/create/4.tanks.sql index df0bdf4..fd5aee4 100644 --- a/script/sql/create/4.tanks.sql +++ b/script/sql/create/4.tanks.sql @@ -6,11 +6,11 @@ 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 ); diff --git a/script/sql/create/5.pipes.sql b/script/sql/create/5.pipes.sql index fb1dc2d..cb04ea6 100644 --- a/script/sql/create/5.pipes.sql +++ b/script/sql/create/5.pipes.sql @@ -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 ); diff --git a/script/sql/create/7.valves.sql b/script/sql/create/7.valves.sql index 7159aac..9de645e 100644 --- a/script/sql/create/7.valves.sql +++ b/script/sql/create/7.valves.sql @@ -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 ); From fd03bdec41d6d1b2c790c68520faacf819038430 Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 22:47:27 +0800 Subject: [PATCH 02/46] Fix junction pattern type --- api/s2_junctions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/api/s2_junctions.py b/api/s2_junctions.py index c8be1c1..9aa2935 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -162,7 +162,7 @@ def set_junction_pattern(name: str, id: str, pattern: str) -> ChangeSet: add_operation(name, redo, undo) change = ChangeSet() - change.update('junction', id, 'pattern', 'float', str(pattern)) + change.update('junction', id, 'pattern', 'str', str(pattern)) return change From 4b398e2619cef2298d8656506db26799c8d2d9dc Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 22:48:06 +0800 Subject: [PATCH 03/46] Add reservoir api --- api/s3_reservoirs.py | 157 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 api/s3_reservoirs.py diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py new file mode 100644 index 0000000..d28622f --- /dev/null +++ b/api/s3_reservoirs.py @@ -0,0 +1,157 @@ +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 add_reservoir(name: str, id: str, x: float, y: float, head: float) -> ChangeSet: + if is_node(name, id): + return + + with conn[name].cursor() as cur: + sql = f"insert into _node (id, type) values ('{id}', 'RESERVOIR');" + sql += f" insert into reservoirs (id, head) values ('{id}', {head});" + 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 reservoirs where id = "{id}";' + undo += f' delete from _node where id = "{id}";' + add_operation(name, redo, undo) + + change = ChangeSet() + change.add('reservoir', id) + return change + +def delete_reservoir(name: str, id: str) -> ChangeSet: + if not is_reservoir(name, id): + return + + with conn[name].cursor(row_factory=dict_row) as cur: + cur.execute(f"select * from reservoirs where id = '{id}'") + row = cur.fetchone() + if row == None: + return + + head = row['head'] + pattern = 'NULL' if row['pattern'] == None else row['pattern'] + pattern = f'"{pattern}"' if pattern != 'NULL' else pattern + + cur.execute(f"select * from coordinates where node = '{id}'") + row = cur.fetchone() + if row == None: + return + + coord = row['coord'] + + sql = f"delete from coordinates where node = '{id}';" + sql += f" delete from reservoirs 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}", "RESERVOIR");' + undo += f' insert into reservoirs (id, head, pattern) values ("{id}", {head}, {pattern});' + undo += f' insert into coordinates (node, coord) values ("{id}", "{coord}");' + add_operation(name, redo, undo) + + change = ChangeSet() + change.delete('reservoir', id) + return change + +def _get_reservoir(name: str, id: str) -> Row | None: + with conn[name].cursor(row_factory=dict_row) as cur: + cur.execute(f"select head, pattern from reservoirs where id = '{id}'") + return cur.fetchone() + +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 _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_reservoir_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_reservoir_head(name: str, id: str, head: float) -> ChangeSet: + if not is_reservoir(name, id): + return + + old = get_reservoir_head(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update reservoirs set head = {head} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update reservoirs set head = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('reservoir', id, 'head', 'float', str(head)) + return change + +def set_reservoir_pattern(name: str, id: str, pattern: str) -> ChangeSet: + if not is_reservoir(name, id): + return + if not is_pattern(name, id): + return + + old = get_reservoir_pattern(name, id) + if old == None: + return + + old = f'"{old}"' if old != 'NULL' else old + + with conn[name].cursor() as cur: + sql = f"update reservoirs set pattern = '{pattern}' where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update reservoirs set pattern = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('reservoir', id, 'pattern', 'str', str(pattern)) + return change + + +def set_reservoir_coord(name: str, id: str, x: float, y: float) -> ChangeSet: + if not is_reservoir(name, id): + return + + old = get_reservoir_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('reservoir', id, 'coord', 'point', str({'x': x, 'y': y})) + return change \ No newline at end of file From cef6ea2cf7ddbc4f4611e9640bb8f46fb989dfbc Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 22:48:35 +0800 Subject: [PATCH 04/46] Add tank api --- api/s4_tanks.py | 333 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 333 insertions(+) create mode 100644 api/s4_tanks.py diff --git a/api/s4_tanks.py b/api/s4_tanks.py new file mode 100644 index 0000000..897e749 --- /dev/null +++ b/api/s4_tanks.py @@ -0,0 +1,333 @@ +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 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: + if is_node(name, id): + return + + with conn[name].cursor() as cur: + sql = f"insert into _node (id, type) values ('{id}', 'TANK');" + 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});" + 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 tanks where id = "{id}";' + undo += f' delete from _node where id = "{id}";' + add_operation(name, redo, undo) + + change = ChangeSet() + change.add('tank', id) + return change + + +def delete_tank(name: str, id: str) -> ChangeSet: + if not is_tank(name, id): + return + + with conn[name].cursor(row_factory=dict_row) as cur: + cur.execute(f"select * from tanks where id = '{id}'") + row = cur.fetchone() + if row == None: + return + + 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 = 'NULL' if row['vol_curve'] == None else row['vol_curve'] + vol_curve = f'"{vol_curve}"' if vol_curve != 'NULL' else vol_curve + overflow = 'NULL' if row['overflow'] == None else row['overflow'] + + cur.execute(f"select * from coordinates where node = '{id}'") + row = cur.fetchone() + if row == None: + return + + coord = row['coord'] + + sql = f"delete from coordinates where node = '{id}';" + sql += f" delete from tanks 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 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});' + undo += f' insert into coordinates (node, coord) values ("{id}", "{coord}");' + add_operation(name, redo, undo) + + change = ChangeSet() + change.delete('tank', id) + return change + + +def _get_tank(name: str, id: str) -> Row | None: + with conn[name].cursor(row_factory=dict_row) as cur: + cur.execute(f"select elevation, init_level, min_level, max_level, diameter, min_vol, vol_curve, overflow from tanks where id = '{id}'") + return cur.fetchone() + + +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 _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_tank_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_tank_elevation(name: str, id: str, elevation: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_elevation(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update tanks set elevation = {elevation} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set elevation = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'elevation', 'float', str(elevation)) + return change + + +def set_tank_init_level(name: str, id: str, init_level: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_init_level(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update tanks set init_level = {init_level} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set init_level = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'init_level', 'float', str(init_level)) + return change + + +def set_tank_min_level(name: str, id: str, min_level: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_min_level(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update tanks set min_level = {min_level} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set min_level = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'min_level', 'float', str(min_level)) + return change + + +def set_tank_max_level(name: str, id: str, max_level: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_max_level(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update tanks set max_level = {max_level} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set max_level = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'max_level', 'float', str(max_level)) + return change + + +def set_tank_diameter(name: str, id: str, diameter: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_diameter(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update tanks set diameter = {diameter} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set diameter = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'diameter', 'float', str(diameter)) + return change + + +def set_tank_min_vol(name: str, id: str, min_vol: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_min_vol(name, id) + if old == None: + return + + with conn[name].cursor() as cur: + sql = f"update tanks set min_vol = {min_vol} where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set min_vol = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'min_vol', 'float', str(min_vol)) + return change + + +def set_tank_vol_curve(name: str, id: str, vol_curve: str) -> ChangeSet: + if not is_tank(name, id): + return + if not is_curve(name, id): + return + + old = get_tank_vol_curve(name, id) + if old == None: + return + + old = f'"{old}"' if old != 'NULL' else old + + with conn[name].cursor() as cur: + sql = f"update tanks set vol_curve = '{vol_curve}' where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set vol_curve = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'vol_curve', 'str', str(vol_curve)) + return change + +OVERFLOW_YES = 'YES' +OVERFLOW_NO = 'NO' + +def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet: + if overflow is not OVERFLOW_YES or overflow is not OVERFLOW_NO: + return + + if not is_tank(name, id): + return + if not is_curve(name, id): + return + + old = get_tank_overflow(name, id) + if old == None: + return + + old = f'"{old}"' if old != 'NULL' else old + + with conn[name].cursor() as cur: + sql = f"update tanks set overflow = '{overflow}' where id = '{id}'" + cur.execute(sql) + redo = sql.replace("'", '"') + undo = f'update tanks set overflow = {old} where id = "{id}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update('tank', id, 'overflow', 'str', str(overflow)) + return change + + +def set_tank_coord(name: str, id: str, x: float, y: float) -> ChangeSet: + if not is_tank(name, id): + return + + old = get_tank_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('tank', id, 'coord', 'point', str({'x': x, 'y': y})) + return change From 06240f1eba6444276e4053d6d84f2131c28894b0 Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 22:49:50 +0800 Subject: [PATCH 05/46] Add new api to tjnetwork --- api/__init__.py | 11 +++++- tjnetwork.py | 97 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 107 insertions(+), 1 deletion(-) diff --git a/api/__init__.py b/api/__init__.py index 408e40e..611c91b 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -20,4 +20,13 @@ 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 \ No newline at end of file +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 \ No newline at end of file diff --git a/tjnetwork.py b/tjnetwork.py index 9e24106..fa7be2c 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -19,6 +19,9 @@ PIPE = api.PIPE PUMP = api.PUMP VALVE = api.VALVE +OVERFLOW_YES = api.OVERFLOW_YES +OVERFLOW_NO = api.OVERFLOW_NO + ############################################################ # project @@ -169,3 +172,97 @@ 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, elevation: float) -> ChangeSet: + return api.add_reservoir(name, reservoir_id, x, y, elevation) + +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, elevation: float) -> ChangeSet: + return api.set_reservoir_head(name, reservoir_id, elevation) + +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) -> ChangeSet: + return api.add_tank(name, tank_id, x, y, elevation) + +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) From 7f26c21435176e04b89397bd99133d5ac5ce214b Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 23:01:16 +0800 Subject: [PATCH 06/46] Refactor coordinate api --- api/s24_coordinates.py | 45 ++++++++++++++++++++++++++++++++++++++++++ api/s2_junctions.py | 40 ++++++++----------------------------- api/s3_reservoirs.py | 38 +++++------------------------------ api/s4_tanks.py | 38 ++++------------------------------- 4 files changed, 62 insertions(+), 99 deletions(-) create mode 100644 api/s24_coordinates.py diff --git a/api/s24_coordinates.py b/api/s24_coordinates.py new file mode 100644 index 0000000..fae0c0d --- /dev/null +++ b/api/s24_coordinates.py @@ -0,0 +1,45 @@ +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, id: str, x: float, y: float) -> ChangeSet: + if not is_junction(name, id): + return + + old = get_node_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 \ No newline at end of file diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 9aa2935..62e1cca 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -3,6 +3,8 @@ from .connection import g_conn_dict as conn from .s0_base import * from .operation import * from .change_set import ChangeSet +from .s24_coordinates import * + def add_junction(name: str, id: str, x: float, y: float, elevation: float) -> ChangeSet: if is_node(name, id): @@ -68,10 +70,12 @@ def _get_junction(name: str, id: str) -> Row | None: 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 +83,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,21 +91,10 @@ 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_elevation(name: str, id: str, elevation: float) -> ChangeSet: if not is_junction(name, id): @@ -167,22 +161,4 @@ def set_junction_pattern(name: str, id: str, pattern: str) -> ChangeSet: def set_junction_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - if not is_junction(name, id): - return - - 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, id, x, y) diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index d28622f..fd3f4b9 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -3,6 +3,8 @@ from .connection import g_conn_dict as conn from .s0_base import * from .operation import * from .change_set import ChangeSet +from .s24_coordinates import * + def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> ChangeSet: if is_node(name, id): @@ -24,6 +26,7 @@ def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> Change change.add('reservoir', id) return change + def delete_reservoir(name: str, id: str) -> ChangeSet: if not is_reservoir(name, id): return @@ -76,21 +79,8 @@ def get_reservoir_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_reservoir_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_reservoir_head(name: str, id: str, head: float) -> ChangeSet: if not is_reservoir(name, id): @@ -136,22 +126,4 @@ def set_reservoir_pattern(name: str, id: str, pattern: str) -> ChangeSet: def set_reservoir_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - if not is_reservoir(name, id): - return - - old = get_reservoir_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('reservoir', id, 'coord', 'point', str({'x': x, 'y': y})) - return change \ No newline at end of file + return set_node_coord(name, id, x, y) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 897e749..5740e9d 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -3,6 +3,8 @@ from .connection import g_conn_dict as conn from .s0_base import * from .operation import * from .change_set import ChangeSet +from .s24_coordinates import * + 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: if is_node(name, id): @@ -120,22 +122,8 @@ def get_tank_overflow(name: str, id: str) -> str | None: 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_tank_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_tank_elevation(name: str, id: str, elevation: float) -> ChangeSet: @@ -312,22 +300,4 @@ def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet: def set_tank_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - if not is_tank(name, id): - return - - old = get_tank_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('tank', id, 'coord', 'point', str({'x': x, 'y': y})) - return change + return set_node_coord(name, id, x, y) From 3ed4afeb8593a759e3e248cad87bedd5c1c971b6 Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 23:01:43 +0800 Subject: [PATCH 07/46] Add new api to tjnetwork --- api/__init__.py | 4 +++- tjnetwork.py | 11 +++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/api/__init__.py b/api/__init__.py index 611c91b..556cb6b 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -29,4 +29,6 @@ from .s3_reservoirs import set_reservoir_head, set_reservoir_pattern, set_reserv 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 \ No newline at end of file +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 .s24_coordinates import get_node_coord, set_node_coord \ No newline at end of file diff --git a/tjnetwork.py b/tjnetwork.py index fa7be2c..cd4e92c 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -266,3 +266,14 @@ def set_tank_overflow(name: str, tank_id: str, overflow: str) -> ChangeSet: def set_tank_coord(name: str, tank_id: str, x: float, y: float) -> ChangeSet: return api.set_tank_coord(name, tank_id, x, y) + + +############################################################ +# coordinates 24.[COORDINATES] +############################################################ + +def get_node_coord(name: str, tank_id: str) -> dict[str, float] | None: + return api.get_node_coord(name, tank_id) + +def set_node_coord(name: str, tank_id: str, x: float, y: float) -> ChangeSet: + return api.set_node_coord(name, tank_id, x, y) From 2fe4826bf298667580109d3d015ec74d70c2310d Mon Sep 17 00:00:00 2001 From: wqy Date: Fri, 16 Sep 2022 23:15:16 +0800 Subject: [PATCH 08/46] Lower type string --- api/s0_base.py | 12 ++++++------ script/sql/create/0.base.sql | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/api/s0_base.py b/api/s0_base.py index 87350a7..37917e9 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -6,12 +6,12 @@ _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: diff --git a/script/sql/create/0.base.sql b/script/sql/create/0.base.sql index 4ee4fde..e936579 100644 --- a/script/sql/create/0.base.sql +++ b/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 ( From 41acd13995f97c1e79d776609aaf7de76c80b428 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 00:04:38 +0800 Subject: [PATCH 09/46] Refactor base --- api/s0_base.py | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/api/s0_base.py b/api/s0_base.py index 37917e9..37d9488 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -1,5 +1,7 @@ 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" @@ -73,3 +75,50 @@ def get_curves(name: str) -> list[str]: 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 + + 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 + + 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 + + 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 From 2575fec547be07713f89d0bfc46e5f6ca51e08e0 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 00:04:50 +0800 Subject: [PATCH 10/46] Add utility --- api/utility.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 api/utility.py diff --git a/api/utility.py b/api/utility.py new file mode 100644 index 0000000..e0d7441 --- /dev/null +++ b/api/utility.py @@ -0,0 +1,21 @@ +from psycopg.rows import dict_row, Row +from .connection import g_conn_dict as conn +from .operation import * + +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, sql: str, undo_sql: str): + with conn[name].cursor() as cur: + cur.execute(sql) + redo = sql.replace("'", '"') + add_operation(name, redo, undo_sql) From 732990237bff216f4049c20dba4a3c875d87d472 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 00:06:20 +0800 Subject: [PATCH 11/46] Refactor junction --- api/s2_junctions.py | 130 +++++++++++--------------------------------- 1 file changed, 31 insertions(+), 99 deletions(-) diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 62e1cca..5c3bfd9 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -4,71 +4,36 @@ 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(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 - 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 - 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 = '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 - 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'] - - 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() + return delete_node(name, JUNCTION, id, sql, undo_sql) def get_junction_elevation(name: str, id: str) -> float | None: @@ -96,68 +61,35 @@ def get_junction_coord(name: str, id: str) -> dict[str, float] | None: return get_node_coord(name, id) -def set_junction_elevation(name: str, id: str, elevation: float) -> ChangeSet: +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 - old = get_junction_elevation(name, id) - if old == None: + row = _get_junction(name, id) + if row == 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) + old = decorate(row[key]) + + sql = f"update junctions set {key} = {value} where id = '{id}'" + undo = f'update junctions set {key} = {old} where id = "{id}"' + update(name, sql, undo) change = ChangeSet() - change.update('junction', id, 'elevation', 'float', str(elevation)) + change.update('junction', id, key, key_type, value) return change +def set_junction_elevation(name: str, id: str, elevation: float) -> ChangeSet: + 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 - - 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', 'str', 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: From 7e34c0bd8656ef467ecc6f8cb2104f270b5909d8 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 00:20:11 +0800 Subject: [PATCH 12/46] More refactor of junction --- api/s2_junctions.py | 17 ++++------------- api/utility.py | 16 ++++++++++++++-- 2 files changed, 18 insertions(+), 15 deletions(-) diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 5c3bfd9..78cb2c1 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -1,10 +1,9 @@ -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 * +import utility def add_junction(name: str, id: str, x: float, y: float, elevation: float) -> ChangeSet: @@ -14,7 +13,7 @@ def add_junction(name: str, id: str, x: float, y: float, elevation: float) -> Ch def _get_junction(name: str, id: str) -> Row | None: - return query(f"select elevation, demand, pattern from junctions where id = '{id}'") + return utility.query(name, f"select elevation, demand, pattern from junctions where id = '{id}'") def delete_junction(name: str, id: str) -> ChangeSet: @@ -69,15 +68,7 @@ def _set_junction(name: str, id: str, key: str, key_type: str, value: str, optio if row == None: return - old = decorate(row[key]) - - sql = f"update junctions set {key} = {value} where id = '{id}'" - undo = f'update junctions set {key} = {old} where id = "{id}"' - update(name, sql, undo) - - change = ChangeSet() - change.update('junction', id, key, key_type, value) - return change + return utility.update(name, JUNCTION, 'junctions', 'id', id, key, key_type, row[key], value, optional) def set_junction_elevation(name: str, id: str, elevation: float) -> ChangeSet: diff --git a/api/utility.py b/api/utility.py index e0d7441..4586cad 100644 --- a/api/utility.py +++ b/api/utility.py @@ -1,12 +1,15 @@ 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 @@ -14,8 +17,17 @@ def decorate(value: str | None, type: str, optional: bool) -> str: value = f'"{value}"' if value != 'NULL' else value return value -def update(name: str, sql: str, undo_sql: str): + +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: + 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("'", '"') - add_operation(name, redo, undo_sql) + undo = f'update {table} set {key} = {old} where {id_key} = "{id_value}"' + add_operation(name, redo, undo) + + change = ChangeSet() + change.update(type, id, key, key_type, value) + return change From bb93a5181772c798bf5c982faeba8f2315938ebf Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:25:21 +0800 Subject: [PATCH 13/46] Refactor reservoir --- api/s3_reservoirs.py | 108 +++++++++++-------------------------------- 1 file changed, 27 insertions(+), 81 deletions(-) diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index fd3f4b9..7dc649c 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -4,74 +4,42 @@ from .s0_base import * from .operation import * from .change_set import ChangeSet from .s24_coordinates import * +import utility def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> ChangeSet: - if is_node(name, id): - return + 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) - with conn[name].cursor() as cur: - sql = f"insert into _node (id, type) values ('{id}', 'RESERVOIR');" - sql += f" insert into reservoirs (id, head) values ('{id}', {head});" - 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 reservoirs where id = "{id}";' - undo += f' delete from _node where id = "{id}";' - add_operation(name, redo, undo) - - change = ChangeSet() - change.add('reservoir', id) - return change +def _get_reservoir(name: str, id: str) -> Row | None: + return utility.query(f"select head, pattern from reservoirs where id = '{id}'") def delete_reservoir(name: str, id: str) -> ChangeSet: if not is_reservoir(name, id): return - with conn[name].cursor(row_factory=dict_row) as cur: - cur.execute(f"select * from reservoirs where id = '{id}'") - row = cur.fetchone() - if row == None: - return + row = _get_reservoir(name, id) + if row == None: + return - head = row['head'] - pattern = 'NULL' if row['pattern'] == None else row['pattern'] - pattern = f'"{pattern}"' if pattern != 'NULL' else pattern + head = row['head'] + pattern = 'NULL' if row['pattern'] == None else row['pattern'] + pattern = f'"{pattern}"' if pattern != 'NULL' else pattern - cur.execute(f"select * from coordinates where node = '{id}'") - row = cur.fetchone() - if row == None: - return + sql = f"delete from reservoirs where id = '{id}';" + undo_sql = f'insert into reservoirs (id, head, pattern) values ("{id}", {head}, {pattern});' - coord = row['coord'] + return delete_node(name, RESERVOIR, id, sql, undo_sql) - sql = f"delete from coordinates where node = '{id}';" - sql += f" delete from reservoirs 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}", "RESERVOIR");' - undo += f' insert into reservoirs (id, head, pattern) values ("{id}", {head}, {pattern});' - undo += f' insert into coordinates (node, coord) values ("{id}", "{coord}");' - add_operation(name, redo, undo) - - change = ChangeSet() - change.delete('reservoir', id) - return change - -def _get_reservoir(name: str, id: str) -> Row | None: - with conn[name].cursor(row_factory=dict_row) as cur: - cur.execute(f"select head, pattern from reservoirs where id = '{id}'") - return cur.fetchone() 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: @@ -79,50 +47,28 @@ def get_reservoir_pattern(name: str, id: str) -> str | None: else: return None + def get_reservoir_coord(name: str, id: str) -> dict[str, float] | None: return get_node_coord(name, id) -def set_reservoir_head(name: str, id: str, head: float) -> ChangeSet: + +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 - old = get_reservoir_head(name, id) - if old == None: + row = _get_reservoir(name, id) + if row == None: return - with conn[name].cursor() as cur: - sql = f"update reservoirs set head = {head} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update reservoirs set head = {old} where id = "{id}"' - add_operation(name, redo, undo) + return utility.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)) - change = ChangeSet() - change.update('reservoir', id, 'head', 'float', str(head)) - return change def set_reservoir_pattern(name: str, id: str, pattern: str) -> ChangeSet: - if not is_reservoir(name, id): - return - if not is_pattern(name, id): - return - - old = get_reservoir_pattern(name, id) - if old == None: - return - - old = f'"{old}"' if old != 'NULL' else old - - with conn[name].cursor() as cur: - sql = f"update reservoirs set pattern = '{pattern}' where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update reservoirs set pattern = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('reservoir', id, 'pattern', 'str', str(pattern)) - return change + return _set_reservoir(name, id, 'pattern', 'str', pattern, True) def set_reservoir_coord(name: str, id: str, x: float, y: float) -> ChangeSet: From ee39d96120cc79b4fb9c9e53fa964f8f734e4f93 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:29:05 +0800 Subject: [PATCH 14/46] Make use of utility decorate --- api/s2_junctions.py | 5 ++--- api/s3_reservoirs.py | 3 +-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 78cb2c1..88d3f73 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -25,9 +25,8 @@ def delete_junction(name: str, id: str) -> ChangeSet: return 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 + demand = utility.decorate(row['demand'], 'float', True) + pattern = utility.decorate(row['pattern'], 'str', True) sql = f"delete from junctions where id = '{id}';" undo_sql = f'insert into junctions (id, elevation, demand, pattern) values ("{id}", {elevation}, {demand}, {pattern});' diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index 7dc649c..e663e39 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -26,8 +26,7 @@ def delete_reservoir(name: str, id: str) -> ChangeSet: return head = row['head'] - pattern = 'NULL' if row['pattern'] == None else row['pattern'] - pattern = f'"{pattern}"' if pattern != 'NULL' else pattern + pattern = utility.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});' From 64b6a1521d02b1689a40958c2de48e965db17bd4 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:43:48 +0800 Subject: [PATCH 15/46] Refactor tank --- api/s4_tanks.py | 235 ++++++++---------------------------------------- 1 file changed, 39 insertions(+), 196 deletions(-) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 5740e9d..e475017 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -1,79 +1,44 @@ -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 * +import utility 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: - if is_node(name, id): - return + 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) - with conn[name].cursor() as cur: - sql = f"insert into _node (id, type) values ('{id}', 'TANK');" - 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});" - 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 tanks where id = "{id}";' - undo += f' delete from _node where id = "{id}";' - add_operation(name, redo, undo) - - change = ChangeSet() - change.add('tank', id) - return change +def _get_tank(name: str, id: str) -> Row | None: + return utility.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 - with conn[name].cursor(row_factory=dict_row) as cur: - cur.execute(f"select * from tanks where id = '{id}'") - row = cur.fetchone() - if row == None: - return + row = _get_tank(name, id) + if row == None: + return - 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 = 'NULL' if row['vol_curve'] == None else row['vol_curve'] - vol_curve = f'"{vol_curve}"' if vol_curve != 'NULL' else vol_curve - overflow = 'NULL' if row['overflow'] == None else row['overflow'] + 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 = 'NULL' if row['vol_curve'] == None else row['vol_curve'] + vol_curve = f'"{vol_curve}"' if vol_curve != 'NULL' else vol_curve + overflow = 'NULL' if row['overflow'] == None else row['overflow'] - cur.execute(f"select * from coordinates where node = '{id}'") - row = cur.fetchone() - if row == None: - return + 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});' - coord = row['coord'] - - sql = f"delete from coordinates where node = '{id}';" - sql += f" delete from tanks 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 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});' - undo += f' insert into coordinates (node, coord) values ("{id}", "{coord}");' - add_operation(name, redo, undo) - - change = ChangeSet() - change.delete('tank', id) - return change - - -def _get_tank(name: str, id: str) -> Row | None: - with conn[name].cursor(row_factory=dict_row) as cur: - cur.execute(f"select elevation, init_level, min_level, max_level, diameter, min_vol, vol_curve, overflow from tanks where id = '{id}'") - return cur.fetchone() + return add_node(name, TANK, id, x, y, sql, undo_sql) def get_tank_elevation(name: str, id: str) -> float | None: @@ -126,177 +91,55 @@ def get_tank_coord(name: str, id: str) -> dict[str, float] | None: return get_node_coord(name, id) -def set_tank_elevation(name: str, id: str, elevation: float) -> ChangeSet: +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 - old = get_tank_elevation(name, id) - if old == None: + row = _get_tank(name, id) + if row == None: return - with conn[name].cursor() as cur: - sql = f"update tanks set elevation = {elevation} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set elevation = {old} where id = "{id}"' - add_operation(name, redo, undo) + return utility.update(name, TANK, 'tanks', 'id', id, key, key_type, row[key], value, optional) - change = ChangeSet() - change.update('tank', id, 'elevation', 'float', str(elevation)) - return change + +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: - if not is_tank(name, id): - return - - old = get_tank_init_level(name, id) - if old == None: - return - - with conn[name].cursor() as cur: - sql = f"update tanks set init_level = {init_level} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set init_level = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'init_level', 'float', str(init_level)) - return change + return _set_tank(name, id, 'init_level', 'float', init_level) def set_tank_min_level(name: str, id: str, min_level: float) -> ChangeSet: - if not is_tank(name, id): - return - - old = get_tank_min_level(name, id) - if old == None: - return - - with conn[name].cursor() as cur: - sql = f"update tanks set min_level = {min_level} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set min_level = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'min_level', 'float', str(min_level)) - return change + return _set_tank(name, id, 'min_level', 'float', min_level) def set_tank_max_level(name: str, id: str, max_level: float) -> ChangeSet: - if not is_tank(name, id): - return - - old = get_tank_max_level(name, id) - if old == None: - return - - with conn[name].cursor() as cur: - sql = f"update tanks set max_level = {max_level} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set max_level = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'max_level', 'float', str(max_level)) - return change + return _set_tank(name, id, 'max_level', 'float', max_level) def set_tank_diameter(name: str, id: str, diameter: float) -> ChangeSet: - if not is_tank(name, id): - return - - old = get_tank_diameter(name, id) - if old == None: - return - - with conn[name].cursor() as cur: - sql = f"update tanks set diameter = {diameter} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set diameter = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'diameter', 'float', str(diameter)) - return change + return _set_tank(name, id, 'diameter', 'float', diameter) def set_tank_min_vol(name: str, id: str, min_vol: float) -> ChangeSet: - if not is_tank(name, id): - return - - old = get_tank_min_vol(name, id) - if old == None: - return - - with conn[name].cursor() as cur: - sql = f"update tanks set min_vol = {min_vol} where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set min_vol = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'min_vol', 'float', str(min_vol)) - return change + 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_tank(name, id): - return - if not is_curve(name, id): - return + if not is_curve(name, vol_curve): + return ChangeSet - old = get_tank_vol_curve(name, id) - if old == None: - return - - old = f'"{old}"' if old != 'NULL' else old - - with conn[name].cursor() as cur: - sql = f"update tanks set vol_curve = '{vol_curve}' where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set vol_curve = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'vol_curve', 'str', str(vol_curve)) - return change + return _set_tank(name, id, 'vol_curve', 'str', vol_curve, True) OVERFLOW_YES = 'YES' OVERFLOW_NO = 'NO' def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet: if overflow is not OVERFLOW_YES or overflow is not OVERFLOW_NO: - return + return ChangeSet() - if not is_tank(name, id): - return - if not is_curve(name, id): - return - - old = get_tank_overflow(name, id) - if old == None: - return - - old = f'"{old}"' if old != 'NULL' else old - - with conn[name].cursor() as cur: - sql = f"update tanks set overflow = '{overflow}' where id = '{id}'" - cur.execute(sql) - redo = sql.replace("'", '"') - undo = f'update tanks set overflow = {old} where id = "{id}"' - add_operation(name, redo, undo) - - change = ChangeSet() - change.update('tank', id, 'overflow', 'str', str(overflow)) - return change + return _set_tank(name, id, 'overflow', 'str', overflow) def set_tank_coord(name: str, id: str, x: float, y: float) -> ChangeSet: From 146048ac62248aebf6f791e7df7737efdd5a5139 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:44:05 +0800 Subject: [PATCH 16/46] Clean junction and reservoir --- api/s2_junctions.py | 4 +++- api/s3_reservoirs.py | 9 +++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 88d3f73..b2b5ad2 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -1,6 +1,5 @@ from psycopg.rows import Row from .s0_base import * -from .operation import * from .change_set import ChangeSet from .s24_coordinates import * import utility @@ -79,6 +78,9 @@ def set_junction_demand(name: str, id: str, demand: float) -> ChangeSet: def set_junction_pattern(name: str, id: str, pattern: str) -> ChangeSet: + if not is_pattern(name, pattern): + return ChangeSet() + return _set_junction(name, id, 'pattern', 'str', pattern, True) diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index e663e39..b47cf2b 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -1,7 +1,5 @@ -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 * import utility @@ -14,7 +12,7 @@ def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> Change def _get_reservoir(name: str, id: str) -> Row | None: - return utility.query(f"select head, pattern from reservoirs where id = '{id}'") + return utility.query(name, f"select head, pattern from reservoirs where id = '{id}'") def delete_reservoir(name: str, id: str) -> ChangeSet: @@ -67,6 +65,9 @@ def set_reservoir_head(name: str, id: str, head: float) -> ChangeSet: 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) From 4f9ffc3b1145cbdfbaae471175e5eeeba6ad3309 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:45:31 +0800 Subject: [PATCH 17/46] Clean tank --- api/s4_tanks.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index e475017..461fc75 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -7,6 +7,10 @@ from .s24_coordinates import * import utility +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}";' @@ -132,8 +136,6 @@ def set_tank_vol_curve(name: str, id: str, vol_curve: str) -> ChangeSet: return _set_tank(name, id, 'vol_curve', 'str', vol_curve, True) -OVERFLOW_YES = 'YES' -OVERFLOW_NO = 'NO' def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet: if overflow is not OVERFLOW_YES or overflow is not OVERFLOW_NO: From efe5b796f345db4ec956fbfe042a19de764b7ba5 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:46:58 +0800 Subject: [PATCH 18/46] Clean tank --- api/s4_tanks.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 461fc75..059566c 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -1,7 +1,5 @@ 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 * import utility From 435411356fbcf56954d88f504d834b1ec92c712c Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:49:07 +0800 Subject: [PATCH 19/46] Lower tank overflow enum --- api/s4_tanks.py | 4 ++-- script/sql/create/4.tanks.sql | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 059566c..f21f66c 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -5,8 +5,8 @@ from .s24_coordinates import * import utility -OVERFLOW_YES = 'YES' -OVERFLOW_NO = 'NO' +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: diff --git a/script/sql/create/4.tanks.sql b/script/sql/create/4.tanks.sql index fd5aee4..963f998 100644 --- a/script/sql/create/4.tanks.sql +++ b/script/sql/create/4.tanks.sql @@ -1,6 +1,6 @@ -- [TANKS] -CREATE TYPE TANKS_OVERFLOW AS ENUM ('YES', 'NO'); +CREATE TYPE TANKS_OVERFLOW AS ENUM ('yes', 'no'); CREATE TABLE TANKS ( From 4761a0d60bb10699d2702880082cb99bb30a3dc0 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 09:56:54 +0800 Subject: [PATCH 20/46] Add link in base --- api/s0_base.py | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/api/s0_base.py b/api/s0_base.py index 37d9488..e4a5032 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -3,6 +3,7 @@ from .connection import g_conn_dict as conn from .operation import * from .change_set import ChangeSet + _NODE = "_node" _LINK = "_link" _CURVE = "_curve" @@ -15,47 +16,59 @@ 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) != {} + 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: @@ -64,18 +77,23 @@ 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 @@ -96,6 +114,7 @@ def add_node(name: str, node_type: str, id: str, x: float, y: float, table_sql: 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 @@ -122,3 +141,41 @@ def delete_node(name: str, node_type: str, id: str, table_sql: str, table_undo_s 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 + + 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_node(name, id): + return + + 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 From 62961cba70f1496ae0cdeb6270fabfa25b7a16e4 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 10:11:47 +0800 Subject: [PATCH 21/46] Make use of utility decorate --- api/s4_tanks.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index f21f66c..c4283a5 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -33,9 +33,8 @@ def delete_tank(name: str, id: str) -> ChangeSet: max_level = row['max_level'] diameter = row['diameter'] min_vol = row['min_vol'] - vol_curve = 'NULL' if row['vol_curve'] == None else row['vol_curve'] - vol_curve = f'"{vol_curve}"' if vol_curve != 'NULL' else vol_curve - overflow = 'NULL' if row['overflow'] == None else row['overflow'] + vol_curve = utility.decorate(row['vol_curve'], 'str', True) + overflow = utility.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});' From ab11d2d134b2ca51759273a5d4a4345e1bc7e78b Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 10:21:17 +0800 Subject: [PATCH 22/46] Add pipe api --- api/s5_pipes.py | 109 ++++++++++++++++++++++++++++++++++ script/sql/create/5.pipes.sql | 2 +- 2 files changed, 110 insertions(+), 1 deletion(-) create mode 100644 api/s5_pipes.py diff --git a/api/s5_pipes.py b/api/s5_pipes.py new file mode 100644 index 0000000..6f6370f --- /dev/null +++ b/api/s5_pipes.py @@ -0,0 +1,109 @@ +from psycopg.rows import Row +from .s0_base import * +from .change_set import ChangeSet +import utility + + +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 + if not is_node(name, node2): + return + + 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 utility.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 + + row = _get_pipe(name, id) + if row == None: + return + + 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_ndoe1(name: str, id: str) -> str | None: + row = _get_pipe(name, id) + return float(row['node1']) if row != None else None + + +def get_pipe_ndoe2(name: str, id: str) -> str | None: + row = _get_pipe(name, id) + return float(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 float(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 + + row = _get_pipe(name, id) + if row == None: + return + + return utility.update(name, PIPE, 'pipes', 'id', id, key, key_type, row[key], value, optional) + + +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 is not PIPE_STATUS_OPEN or status is not PIPE_STATUS_CLOSED or status is not PIPE_STATUS_CV: + return ChangeSet() + + return _set_pipe(name, id, 'status', 'str', str(status)) diff --git a/script/sql/create/5.pipes.sql b/script/sql/create/5.pipes.sql index cb04ea6..74c4982 100644 --- a/script/sql/create/5.pipes.sql +++ b/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 ( From 01225c309c06431a0af1f81c12887b688798392e Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 10:39:53 +0800 Subject: [PATCH 23/46] Fix utility update --- api/utility.py | 1 + 1 file changed, 1 insertion(+) diff --git a/api/utility.py b/api/utility.py index 4586cad..379a2bc 100644 --- a/api/utility.py +++ b/api/utility.py @@ -19,6 +19,7 @@ def decorate(value: str | None, type: str, optional: bool) -> str: 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: From 311f067c22f5bb929050152801571eb67e2ef6c5 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 10:45:35 +0800 Subject: [PATCH 24/46] Add pipe api to tjnetwork --- api/__init__.py | 5 ++++ api/s5_pipes.py | 18 +++++++++++++-- tjnetwork.py | 61 +++++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 80 insertions(+), 4 deletions(-) diff --git a/api/__init__.py b/api/__init__.py index 556cb6b..6a50dfa 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -31,4 +31,9 @@ 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 .s24_coordinates import get_node_coord, set_node_coord \ No newline at end of file diff --git a/api/s5_pipes.py b/api/s5_pipes.py index 6f6370f..18132b3 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -40,12 +40,12 @@ def delete_pipe(name: str, id: str) -> ChangeSet: return delete_link(name, PIPE, id, sql, undo_sql) -def get_pipe_ndoe1(name: str, id: str) -> str | None: +def get_pipe_node1(name: str, id: str) -> str | None: row = _get_pipe(name, id) return float(row['node1']) if row != None else None -def get_pipe_ndoe2(name: str, id: str) -> str | None: +def get_pipe_node2(name: str, id: str) -> str | None: row = _get_pipe(name, id) return float(row['node2']) if row != None else None @@ -86,6 +86,20 @@ def _set_pipe(name: str, id: str, key: str, key_type: str, value: str, optional: return utility.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 + + 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 + + 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)) diff --git a/tjnetwork.py b/tjnetwork.py index cd4e92c..a71ecab 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -22,6 +22,10 @@ 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 + ############################################################ # project @@ -207,8 +211,8 @@ def set_reservoir_coord(name: str, reservoir_id: str, x: float, y: float) -> Cha # tank 4.[TANKS] ############################################################ -def add_tank(name: str, tank_id: str, x: float, y: float, elevation: float) -> ChangeSet: - return api.add_tank(name, tank_id, x, y, elevation) +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) @@ -268,6 +272,59 @@ 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, id: str) -> ChangeSet: + return api.delete_pipe(name, id) + +def get_pipe_node1(name: str, id: str) -> str | None: + return api.get_pipe_node1(name, id) + +def get_pipe_node2(name: str, id: str) -> str | None: + return api.get_pipe_node2(name, id) + +def get_pipe_length(name: str, id: str) -> float | None: + return api.get_pipe_length(name, id) + +def get_pipe_diameter(name: str, id: str) -> float | None: + return api.get_pipe_diameter(name, id) + +def get_pipe_roughness(name: str, id: str) -> float | None: + return api.get_pipe_roughness(name, id) + +def get_pipe_minor_loss(name: str, id: str) -> float | None: + return api.get_pipe_minor_loss(name, id) + +def get_pipe_status(name: str, id: str) -> str | None: + return api.get_pipe_status(name, id) + +def set_pipe_node1(name: str, id: str, node1: str) -> ChangeSet: + return api.set_pipe_node1(name, id, node1) + +def set_pipe_node2(name: str, id: str, node2: str) -> ChangeSet: + return api.set_pipe_node2(name, id, node2) + +def set_pipe_length(name: str, id: str, length: float) -> ChangeSet: + return api.set_pipe_length(name, id, length) + +def set_pipe_diameter(name: str, id: str, diameter: float) -> ChangeSet: + return api.set_pipe_diameter(name, id, diameter) + +def set_pipe_roughness(name: str, id: str, roughness: float) -> ChangeSet: + return api.set_pipe_roughness(name, id, roughness) + +def set_pipe_minor_loss(name: str, id: str, minor_loss: float) -> ChangeSet: + return api.set_pipe_minor_loss(name, id, minor_loss) + +def set_pipe_status(name: str, id: str, status: float) -> ChangeSet: + return api.set_pipe_status(name, id, status) + + ############################################################ # coordinates 24.[COORDINATES] ############################################################ From 3250d5873330d05dfc33b44dfcff8bc11c8ce820 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 11:10:28 +0800 Subject: [PATCH 25/46] Add pump api --- api/s6_pumps.py | 79 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 api/s6_pumps.py diff --git a/api/s6_pumps.py b/api/s6_pumps.py new file mode 100644 index 0000000..875265e --- /dev/null +++ b/api/s6_pumps.py @@ -0,0 +1,79 @@ +from psycopg.rows import Row +from .s0_base import * +from .change_set import ChangeSet +import utility + + +def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet: + if not is_node(name, node1): + return + if not is_node(name, node2): + return + + 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 utility.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 + + row = _get_pump(name, id) + if row == None: + return + + 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 float(row['node1']) if row != None else None + + +def get_pump_node2(name: str, id: str) -> str | None: + row = _get_pump(name, id) + return float(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 + + row = _get_pump(name, id) + if row == None: + return + + return utility.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 + + 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 + + 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 \ No newline at end of file From 4350b5d19e88318f8da50ade6e6d148180237392 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 11:16:45 +0800 Subject: [PATCH 26/46] Add pump api to tjnetwork --- api/__init__.py | 5 +++ api/s6_pumps.py | 5 ++- tjnetwork.py | 91 +++++++++++++++++++++++++++++++------------------ 3 files changed, 66 insertions(+), 35 deletions(-) diff --git a/api/__init__.py b/api/__init__.py index 6a50dfa..b671e8f 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -36,4 +36,9 @@ 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 .s24_coordinates import get_node_coord, set_node_coord \ No newline at end of file diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 875265e..9935678 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -44,11 +44,13 @@ def get_pump_node2(name: str, id: str) -> str | None: row = _get_pump(name, id) return float(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 @@ -73,7 +75,8 @@ def set_pump_node2(name: str, id: str, node2: str) -> 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 \ No newline at end of file +def set_pump_pattern(name: str, id: str) -> ChangeSet: pass diff --git a/tjnetwork.py b/tjnetwork.py index a71ecab..2b3b825 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -279,58 +279,81 @@ def set_tank_coord(name: str, tank_id: str, x: float, y: float) -> ChangeSet: 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, id: str) -> ChangeSet: - return api.delete_pipe(name, id) +def delete_pipe(name: str, pipe_id: str) -> ChangeSet: + return api.delete_pipe(name, pipe_id) -def get_pipe_node1(name: str, id: str) -> str | None: - return api.get_pipe_node1(name, 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, id: str) -> str | None: - return api.get_pipe_node2(name, 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, id: str) -> float | None: - return api.get_pipe_length(name, 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, id: str) -> float | None: - return api.get_pipe_diameter(name, 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, id: str) -> float | None: - return api.get_pipe_roughness(name, 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, id: str) -> float | None: - return api.get_pipe_minor_loss(name, 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, id: str) -> str | None: - return api.get_pipe_status(name, 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, id: str, node1: str) -> ChangeSet: - return api.set_pipe_node1(name, id, node1) +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, id: str, node2: str) -> ChangeSet: - return api.set_pipe_node2(name, id, node2) +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, id: str, length: float) -> ChangeSet: - return api.set_pipe_length(name, id, length) +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, id: str, diameter: float) -> ChangeSet: - return api.set_pipe_diameter(name, id, diameter) +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, id: str, roughness: float) -> ChangeSet: - return api.set_pipe_roughness(name, id, roughness) +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, id: str, minor_loss: float) -> ChangeSet: - return api.set_pipe_minor_loss(name, id, minor_loss) +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, id: str, status: float) -> ChangeSet: - return api.set_pipe_status(name, id, status) +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) ############################################################ # coordinates 24.[COORDINATES] ############################################################ -def get_node_coord(name: str, tank_id: str) -> dict[str, float] | None: - return api.get_node_coord(name, tank_id) +def get_node_coord(name: str, node_id: str) -> dict[str, float] | None: + return api.get_node_coord(name, node_id) -def set_node_coord(name: str, tank_id: str, x: float, y: float) -> ChangeSet: - return api.set_node_coord(name, tank_id, x, y) +def set_node_coord(name: str, node_id: str, x: float, y: float) -> ChangeSet: + return api.set_node_coord(name, node_id, x, y) From 391ea0386c51a494ad22cb38966a3a5afefc5386 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:02:48 +0800 Subject: [PATCH 27/46] Fix enum checking --- api/s4_tanks.py | 2 +- api/s5_pipes.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index c4283a5..f4e3f77 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -135,7 +135,7 @@ def set_tank_vol_curve(name: str, id: str, vol_curve: str) -> ChangeSet: def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet: - if overflow is not OVERFLOW_YES or overflow is not OVERFLOW_NO: + if overflow != OVERFLOW_YES and overflow != OVERFLOW_NO: return ChangeSet() return _set_tank(name, id, 'overflow', 'str', overflow) diff --git a/api/s5_pipes.py b/api/s5_pipes.py index 18132b3..2875a33 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -117,7 +117,7 @@ def set_pipe_minor_loss(name: str, id: str, minor_loss: float) -> ChangeSet: def set_pipe_status(name: str, id: str, status: float) -> ChangeSet: - if status is not PIPE_STATUS_OPEN or status is not PIPE_STATUS_CLOSED or status is not PIPE_STATUS_CV: + 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)) From 58e1e447f9e8eb8db9037838ede0afc5286e8c98 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:03:28 +0800 Subject: [PATCH 28/46] Add valve api --- api/s7_valves.py | 121 +++++++++++++++++++++++++++++++++ script/sql/create/7.valves.sql | 2 +- 2 files changed, 122 insertions(+), 1 deletion(-) create mode 100644 api/s7_valves.py diff --git a/api/s7_valves.py b/api/s7_valves.py new file mode 100644 index 0000000..0bdf8c5 --- /dev/null +++ b/api/s7_valves.py @@ -0,0 +1,121 @@ +from psycopg.rows import Row +from .s0_base import * +from .change_set import ChangeSet +import utility + + +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 + if not is_node(name, node2): + return + + 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 utility.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 + + row = _get_valve(name, id) + if row == None: + return + + 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 float(row['node1']) if row != None else None + + +def get_valve_node2(name: str, id: str) -> str | None: + row = _get_valve(name, id) + return float(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 float(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 + + row = _get_valve(name, id) + if row == None: + return + + return utility.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 + + 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 + + return _set_valve(name, id, 'node2', 'str', str(node2)) + + +def set_valve_length(name: str, id: str, length: float) -> ChangeSet: + return _set_valve(name, id, 'length', 'float', str(length)) + + +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: float) -> 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', 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)) diff --git a/script/sql/create/7.valves.sql b/script/sql/create/7.valves.sql index 9de645e..1a887f1 100644 --- a/script/sql/create/7.valves.sql +++ b/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 ( From a72115e15f86ef1ddbf48eaec41c7a1119f536b4 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:30:04 +0800 Subject: [PATCH 29/46] Add valve api to tjnetwork --- api/__init__.py | 5 +++++ tjnetwork.py | 54 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/api/__init__.py b/api/__init__.py index b671e8f..831eb98 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -41,4 +41,9 @@ 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 \ No newline at end of file diff --git a/tjnetwork.py b/tjnetwork.py index 2b3b825..f5b215d 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -26,6 +26,13 @@ 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 @@ -348,6 +355,53 @@ 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_node1(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) + + ############################################################ # coordinates 24.[COORDINATES] ############################################################ From b52515b26f104b729f97ddfaaca069bd6067ade0 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:31:00 +0800 Subject: [PATCH 30/46] Return empty change set --- api/s0_base.py | 8 ++++---- api/s24_coordinates.py | 7 ++++--- api/s2_junctions.py | 8 ++++---- api/s3_reservoirs.py | 8 ++++---- api/s4_tanks.py | 14 +++++++------- api/s5_pipes.py | 16 ++++++++-------- api/s6_pumps.py | 16 ++++++++-------- api/s7_valves.py | 20 ++++++++------------ 8 files changed, 47 insertions(+), 50 deletions(-) diff --git a/api/s0_base.py b/api/s0_base.py index e4a5032..e984143 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -96,7 +96,7 @@ def get_patterns(name: str) -> list[str]: 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 + return ChangeSet() with conn[name].cursor() as cur: sql = f"insert into _node (id, type) values ('{id}', '{node_type}'); " @@ -117,7 +117,7 @@ def add_node(name: str, node_type: str, id: str, x: float, y: float, table_sql: 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 + return ChangeSet() with conn[name].cursor(row_factory=dict_row) as cur: cur.execute(f"select * from coordinates where node = '{id}'") @@ -145,7 +145,7 @@ def delete_node(name: str, node_type: str, id: str, table_sql: str, table_undo_s def add_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: str) -> ChangeSet: if is_link(name, id): - return + return ChangeSet() with conn[name].cursor() as cur: sql = f"insert into _link (id, type) values ('{id}', '{link_type}'); " @@ -164,7 +164,7 @@ def add_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: def delete_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: str) -> ChangeSet: if not is_node(name, id): - return + return ChangeSet() with conn[name].cursor(row_factory=dict_row) as cur: sql = table_sql diff --git a/api/s24_coordinates.py b/api/s24_coordinates.py index fae0c0d..268574a 100644 --- a/api/s24_coordinates.py +++ b/api/s24_coordinates.py @@ -25,11 +25,12 @@ def get_node_coord(name: str, id: str) -> dict[str, float] | None: def set_node_coord(name: str, id: str, x: float, y: float) -> ChangeSet: if not is_junction(name, id): - return + return ChangeSet() old = get_node_coord(name, id) if old == None: - return + return ChangeSet() + old_x, old_y = old['x'], old['y'] with conn[name].cursor() as cur: @@ -42,4 +43,4 @@ def set_node_coord(name: str, id: str, x: float, y: float) -> ChangeSet: change = ChangeSet() change.update('junction', id, 'coord', 'point', str({'x': x, 'y': y})) - return change \ No newline at end of file + return change diff --git a/api/s2_junctions.py b/api/s2_junctions.py index b2b5ad2..b5e788d 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -17,11 +17,11 @@ def _get_junction(name: str, id: str) -> Row | None: def delete_junction(name: str, id: str) -> ChangeSet: if not is_junction(name, id): - return + return ChangeSet() row = _get_junction(name, id) if row == None: - return + return ChangeSet() elevation = row['elevation'] demand = utility.decorate(row['demand'], 'float', True) @@ -60,11 +60,11 @@ def get_junction_coord(name: str, id: str) -> dict[str, float] | None: 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 + return ChangeSet() row = _get_junction(name, id) if row == None: - return + return ChangeSet() return utility.update(name, JUNCTION, 'junctions', 'id', id, key, key_type, row[key], value, optional) diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index b47cf2b..3b48bff 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -17,11 +17,11 @@ def _get_reservoir(name: str, id: str) -> Row | None: def delete_reservoir(name: str, id: str) -> ChangeSet: if not is_reservoir(name, id): - return + return ChangeSet() row = _get_reservoir(name, id) if row == None: - return + return ChangeSet() head = row['head'] pattern = utility.decorate(row['pattern'], 'str', True) @@ -51,11 +51,11 @@ def get_reservoir_coord(name: str, id: str) -> dict[str, float] | None: 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 + return ChangeSet() row = _get_reservoir(name, id) if row == None: - return + return ChangeSet() return utility.update(name, RESERVOIR, 'reservoirs', 'id', id, key, key_type, row[key], value, optional) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index f4e3f77..2a76002 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -21,11 +21,11 @@ def _get_tank(name: str, id: str) -> Row | None: def delete_tank(name: str, id: str) -> ChangeSet: if not is_tank(name, id): - return + return ChangeSet() row = _get_tank(name, id) if row == None: - return + return ChangeSet() elevation = row['elevation'] init_level = row['init_level'] @@ -36,10 +36,10 @@ def delete_tank(name: str, id: str) -> ChangeSet: vol_curve = utility.decorate(row['vol_curve'], 'str', True) overflow = utility.decorate(row['overflow'], 'str', True) - sql += f"delete from tanks where id = '{id}';" + 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 add_node(name, TANK, id, x, y, sql, undo_sql) + return delete_node(name, TANK, id, sql, undo_sql) def get_tank_elevation(name: str, id: str) -> float | None: @@ -94,11 +94,11 @@ def get_tank_coord(name: str, id: str) -> dict[str, float] | None: 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 + return ChangeSet() row = _get_tank(name, id) if row == None: - return + return ChangeSet() return utility.update(name, TANK, 'tanks', 'id', id, key, key_type, row[key], value, optional) @@ -129,7 +129,7 @@ def set_tank_min_vol(name: str, id: str, min_vol: float) -> ChangeSet: def set_tank_vol_curve(name: str, id: str, vol_curve: str) -> ChangeSet: if not is_curve(name, vol_curve): - return ChangeSet + return ChangeSet() return _set_tank(name, id, 'vol_curve', 'str', vol_curve, True) diff --git a/api/s5_pipes.py b/api/s5_pipes.py index 2875a33..0c50527 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -11,9 +11,9 @@ 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 + return ChangeSet() if not is_node(name, node2): - return + 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}";' @@ -26,11 +26,11 @@ def _get_pipe(name: str, id: str) -> Row | None: def delete_pipe(name: str, id: str) -> ChangeSet: if not is_pipe(name, id): - return + return ChangeSet() row = _get_pipe(name, id) if row == None: - return + 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'] @@ -77,25 +77,25 @@ def get_pipe_status(name: str, id: str) -> str | 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 + return ChangeSet() row = _get_pipe(name, id) if row == None: - return + return ChangeSet() return utility.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 + 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 + return ChangeSet() return _set_pipe(name, id, 'node2', 'str', str(node2)) diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 9935678..8e997ab 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -6,9 +6,9 @@ import utility def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet: if not is_node(name, node1): - return + return ChangeSet() if not is_node(name, node2): - return + return ChangeSet() sql = f"insert into pumps (id, node1, node2) values ('{id}', '{node1}', '{node2}'');" undo_sql = f'delete from pumps where id = "{id}";' @@ -21,11 +21,11 @@ def _get_pump(name: str, id: str) -> Row | None: def delete_pump(name: str, id: str) -> ChangeSet: if not is_pump(name, id): - return + return ChangeSet() row = _get_pump(name, id) if row == None: - return + return ChangeSet() node1, node2 = row['node1'], row['node2'] @@ -53,25 +53,25 @@ 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 + return ChangeSet() row = _get_pump(name, id) if row == None: - return + return ChangeSet() return utility.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 + 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 + return ChangeSet() return _set_pump(name, id, 'node2', 'str', str(node2)) diff --git a/api/s7_valves.py b/api/s7_valves.py index 0bdf8c5..139606b 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -14,9 +14,9 @@ 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 + return ChangeSet() if not is_node(name, node2): - return + 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}";' @@ -29,11 +29,11 @@ def _get_valve(name: str, id: str) -> Row | None: def delete_valve(name: str, id: str) -> ChangeSet: if not is_valve(name, id): - return + return ChangeSet() row = _get_valve(name, id) if row == None: - return + return ChangeSet() node1, node2, diameter, type, setting, minor_loss = row['node1'], row['node2'], row['diameter'], row['type'], row['setting'], row['minor_loss'] @@ -86,31 +86,27 @@ def _set_valve(name: str, id: str, key: str, key_type: str, value: str, optional def set_valve_node1(name: str, id: str, node1: str) -> ChangeSet: if not is_node(name, node1): - return + 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 + return ChangeSet() return _set_valve(name, id, 'node2', 'str', str(node2)) -def set_valve_length(name: str, id: str, length: float) -> ChangeSet: - return _set_valve(name, id, 'length', 'float', str(length)) - - 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: float) -> ChangeSet: +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', str(type)) + return _set_valve(name, id, 'type', 'str', type) def set_valve_setting(name: str, id: str, setting: float) -> ChangeSet: From 47e0b48025e5c3cc7100ecb25d8fdeb3ffd33d5a Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:41:10 +0800 Subject: [PATCH 31/46] Add host for linux --- api/project.py | 8 ++++---- script/template.py | 10 +++++----- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/api/project.py b/api/project.py index f283c85..0853e1c 100644 --- a/api/project.py +++ b/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 diff --git a/script/template.py b/script/template.py index c219802..e6e34a8 100644 --- a/script/template.py +++ b/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") From 8cf5895f1d0ea5b02807476dd5be22e025ddb897 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:42:12 +0800 Subject: [PATCH 32/46] Fix module import --- api/s2_junctions.py | 10 +++++----- api/s3_reservoirs.py | 8 ++++---- api/s4_tanks.py | 10 +++++----- api/s5_pipes.py | 6 +++--- api/s6_pumps.py | 6 +++--- api/s7_valves.py | 6 +++--- 6 files changed, 23 insertions(+), 23 deletions(-) diff --git a/api/s2_junctions.py b/api/s2_junctions.py index b5e788d..6c029c0 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -2,7 +2,7 @@ from psycopg.rows import Row from .s0_base import * from .change_set import ChangeSet from .s24_coordinates import * -import utility +from .utility import * def add_junction(name: str, id: str, x: float, y: float, elevation: float) -> ChangeSet: @@ -12,7 +12,7 @@ def add_junction(name: str, id: str, x: float, y: float, elevation: float) -> Ch def _get_junction(name: str, id: str) -> Row | None: - return utility.query(name, f"select elevation, demand, pattern from junctions where id = '{id}'") + return query(name, f"select elevation, demand, pattern from junctions where id = '{id}'") def delete_junction(name: str, id: str) -> ChangeSet: @@ -24,8 +24,8 @@ def delete_junction(name: str, id: str) -> ChangeSet: return ChangeSet() elevation = row['elevation'] - demand = utility.decorate(row['demand'], 'float', True) - pattern = utility.decorate(row['pattern'], 'str', True) + demand = decorate(row['demand'], 'float', True) + pattern = decorate(row['pattern'], 'str', True) sql = f"delete from junctions where id = '{id}';" undo_sql = f'insert into junctions (id, elevation, demand, pattern) values ("{id}", {elevation}, {demand}, {pattern});' @@ -66,7 +66,7 @@ def _set_junction(name: str, id: str, key: str, key_type: str, value: str, optio if row == None: return ChangeSet() - return utility.update(name, JUNCTION, 'junctions', 'id', id, key, key_type, row[key], value, optional) + 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: diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index 3b48bff..7eb58bc 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -2,7 +2,7 @@ from psycopg.rows import Row from .s0_base import * from .change_set import ChangeSet from .s24_coordinates import * -import utility +from .utility import * def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> ChangeSet: @@ -12,7 +12,7 @@ def add_reservoir(name: str, id: str, x: float, y: float, head: float) -> Change def _get_reservoir(name: str, id: str) -> Row | None: - return utility.query(name, f"select head, pattern from reservoirs where id = '{id}'") + return query(name, f"select head, pattern from reservoirs where id = '{id}'") def delete_reservoir(name: str, id: str) -> ChangeSet: @@ -24,7 +24,7 @@ def delete_reservoir(name: str, id: str) -> ChangeSet: return ChangeSet() head = row['head'] - pattern = utility.decorate(row['pattern'], 'str', True) + 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});' @@ -57,7 +57,7 @@ def _set_reservoir(name: str, id: str, key: str, key_type: str, value: str, opti if row == None: return ChangeSet() - return utility.update(name, RESERVOIR, 'reservoirs', 'id', id, key, key_type, row[key], value, optional) + 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: diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 2a76002..1707172 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -2,7 +2,7 @@ from psycopg.rows import Row from .s0_base import * from .change_set import ChangeSet from .s24_coordinates import * -import utility +from .utility import * OVERFLOW_YES = 'yes' @@ -16,7 +16,7 @@ def add_tank(name: str, id: str, x: float, y: float, elevation: float, init_leve def _get_tank(name: str, id: str) -> Row | None: - return utility.query(name, f"select elevation, init_level, min_level, max_level, diameter, min_vol, vol_curve, overflow from tanks where id = '{id}'") + 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: @@ -33,8 +33,8 @@ def delete_tank(name: str, id: str) -> ChangeSet: max_level = row['max_level'] diameter = row['diameter'] min_vol = row['min_vol'] - vol_curve = utility.decorate(row['vol_curve'], 'str', True) - overflow = utility.decorate(row['overflow'], 'str', True) + 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});' @@ -100,7 +100,7 @@ def _set_tank(name: str, id: str, key: str, key_type: str, value: str, optional: if row == None: return ChangeSet() - return utility.update(name, TANK, 'tanks', 'id', id, key, key_type, row[key], value, optional) + 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: diff --git a/api/s5_pipes.py b/api/s5_pipes.py index 0c50527..f9ca77c 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -1,7 +1,7 @@ from psycopg.rows import Row from .s0_base import * from .change_set import ChangeSet -import utility +from .utility import * PIPE_STATUS_OPEN = 'open' @@ -21,7 +21,7 @@ def add_pipe(name: str, id: str, node1: str, node2: str, length: float = 0, diam def _get_pipe(name: str, id: str) -> Row | None: - return utility.query(name, f"select node1, node2, length, diameter, roughness, minor_loss, status from pipes where id = '{id}'") + 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: @@ -83,7 +83,7 @@ def _set_pipe(name: str, id: str, key: str, key_type: str, value: str, optional: if row == None: return ChangeSet() - return utility.update(name, PIPE, 'pipes', 'id', id, key, key_type, row[key], value, optional) + 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: diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 8e997ab..6e7aefc 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -1,7 +1,7 @@ from psycopg.rows import Row from .s0_base import * from .change_set import ChangeSet -import utility +from .utility import * def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet: @@ -16,7 +16,7 @@ def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet: def _get_pump(name: str, id: str) -> Row | None: - return utility.query(name, f"select node1, node2 from pumps where id = '{id}'") + return query(name, f"select node1, node2 from pumps where id = '{id}'") def delete_pump(name: str, id: str) -> ChangeSet: @@ -59,7 +59,7 @@ def _set_pump(name: str, id: str, key: str, key_type: str, value: str, optional: if row == None: return ChangeSet() - return utility.update(name, PUMP, 'pumps', 'id', id, key, key_type, row[key], value, optional) + 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: diff --git a/api/s7_valves.py b/api/s7_valves.py index 139606b..496045c 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -1,7 +1,7 @@ from psycopg.rows import Row from .s0_base import * from .change_set import ChangeSet -import utility +from .utility import * VALVES_TYPE_PRV = 'prv' @@ -24,7 +24,7 @@ def add_valve(name: str, id: str, node1: str, node2: str, diameter: float = 0, t def _get_valve(name: str, id: str) -> Row | None: - return utility.query(name, f"select node1, node2, diameter, type, setting, minor_loss from valves where id = '{id}'") + 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: @@ -81,7 +81,7 @@ def _set_valve(name: str, id: str, key: str, key_type: str, value: str, optional if row == None: return - return utility.update(name, VALVE, 'valves', 'id', id, key, key_type, row[key], value, optional) + 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: From 3f8c218bb0449b15f2629600f42e85a08e5b003d Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 18:53:57 +0800 Subject: [PATCH 33/46] Add test framework --- test_tjnetwork.py | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 test_tjnetwork.py diff --git a/test_tjnetwork.py b/test_tjnetwork.py new file mode 100644 index 0000000..efe3bba --- /dev/null +++ b/test_tjnetwork.py @@ -0,0 +1,44 @@ +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, project): + close_project(p) + delete_project(p) + + def test_title(self): + pass + + def test_junction(self): + pass + + def test_reservoir(self): + pass + + def test_tank(self): + pass + + def test_pipe(self): + pass + + def test_pump(self): + pass + + def test_valve(self): + pass + + def test_coordinate(self): + pass + +if __name__ == '__main__': + pytest.main() From 89ffd15b7b0c70366e14ed31a06153712f6cc9a2 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 19:19:39 +0800 Subject: [PATCH 34/46] Add title & junction test case --- api/utility.py | 2 +- test_tjnetwork.py | 68 +++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 67 insertions(+), 3 deletions(-) diff --git a/api/utility.py b/api/utility.py index 379a2bc..f7e417a 100644 --- a/api/utility.py +++ b/api/utility.py @@ -30,5 +30,5 @@ def update(name: str, type: str, table: str, id_key: str, id_value: str, key: st add_operation(name, redo, undo) change = ChangeSet() - change.update(type, id, key, key_type, value) + change.update(type, id_value, key, key_type, value) return change diff --git a/test_tjnetwork.py b/test_tjnetwork.py index efe3bba..9f7e02a 100644 --- a/test_tjnetwork.py +++ b/test_tjnetwork.py @@ -12,14 +12,78 @@ class TestApi: create_project(p) open_project(p) - def leave(self, project): + def leave(self, p): close_project(p) delete_project(p) def test_title(self): - pass + 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 + + 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" + + 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" + + 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) + pass def test_reservoir(self): From b8d2efdc6628956f860e3b03a56e2891d492600a Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 19:38:43 +0800 Subject: [PATCH 35/46] Add reservoir test case --- api/s24_coordinates.py | 7 ++----- api/s2_junctions.py | 5 ++++- api/s3_reservoirs.py | 5 ++++- api/s4_tanks.py | 5 ++++- test_tjnetwork.py | 47 +++++++++++++++++++++++++++++++++++------- tjnetwork.py | 8 +++---- 6 files changed, 57 insertions(+), 20 deletions(-) diff --git a/api/s24_coordinates.py b/api/s24_coordinates.py index 268574a..2337f09 100644 --- a/api/s24_coordinates.py +++ b/api/s24_coordinates.py @@ -23,10 +23,7 @@ def get_node_coord(name: str, id: str) -> dict[str, float] | None: return _to_point(coord) -def set_node_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - if not is_junction(name, id): - return ChangeSet() - +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() @@ -42,5 +39,5 @@ def set_node_coord(name: str, id: str, x: float, y: float) -> ChangeSet: add_operation(name, redo, undo) change = ChangeSet() - change.update('junction', id, 'coord', 'point', str({'x': x, 'y': y})) + change.update(node_type, id, 'coord', 'point', str({'x': x, 'y': y})) return change diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 6c029c0..3e8df88 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -85,4 +85,7 @@ def set_junction_pattern(name: str, id: str, pattern: str) -> ChangeSet: def set_junction_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - return set_node_coord(name, id, x, y) + if not is_junction(name, id): + return ChangeSet() + + return set_node_coord(name, JUNCTION, id, x, y) diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index 7eb58bc..7394f75 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -72,4 +72,7 @@ def set_reservoir_pattern(name: str, id: str, pattern: str) -> ChangeSet: def set_reservoir_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - return set_node_coord(name, id, x, y) + if not is_reservoir(name, id): + return ChangeSet() + + return set_node_coord(name, RESERVOIR, id, x, y) diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 1707172..6302ac9 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -142,4 +142,7 @@ def set_tank_overflow(name: str, id: str, overflow: str) -> ChangeSet: def set_tank_coord(name: str, id: str, x: float, y: float) -> ChangeSet: - return set_node_coord(name, id, x, y) + if not is_tank(name, id): + return ChangeSet() + + return set_node_coord(name, TANK, id, x, y) diff --git a/test_tjnetwork.py b/test_tjnetwork.py index 9f7e02a..7d47a1a 100644 --- a/test_tjnetwork.py +++ b/test_tjnetwork.py @@ -36,7 +36,7 @@ class TestApi: 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]['type'] == JUNCTION assert change_set.added[0]['id'] == "j0" coord = get_junction_coord(p, 'j0') assert coord['x'] == 0.0 @@ -48,16 +48,18 @@ class TestApi: 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]['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]['type'] == JUNCTION assert change_set.added[0]['id'] == "j1" nodes = get_nodes(p) @@ -67,7 +69,7 @@ class TestApi: change_set = delete_junction(p, 'j1') assert len(change_set.deleted) == 1 - assert change_set.deleted[0]['type'] == 'junction' + assert change_set.deleted[0]['type'] == JUNCTION assert change_set.deleted[0]['id'] == "j1" nodes = get_nodes(p) @@ -76,7 +78,7 @@ class TestApi: change_set = delete_junction(p, 'j0') assert len(change_set.deleted) == 1 - assert change_set.deleted[0]['type'] == 'junction' + assert change_set.deleted[0]['type'] == JUNCTION assert change_set.deleted[0]['id'] == "j0" nodes = get_nodes(p) @@ -84,10 +86,39 @@ class TestApi: self.leave(p) - pass - def test_reservoir(self): - pass + 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" + + 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 } + + 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" + + self.leave(p) def test_tank(self): pass diff --git a/tjnetwork.py b/tjnetwork.py index f5b215d..9d8cddb 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -189,8 +189,8 @@ def set_junction_coord(name: str, junction_id: str, x: float, y: float) -> Chang # reservoir 3.[RESERVOIRS] ############################################################ -def add_reservoir(name: str, reservoir_id: str, x: float, y: float, elevation: float) -> ChangeSet: - return api.add_reservoir(name, reservoir_id, x, y, elevation) +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) @@ -204,8 +204,8 @@ def get_reservoir_pattern(name: str, reservoir_id: str) -> str | None: 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, elevation: float) -> ChangeSet: - return api.set_reservoir_head(name, reservoir_id, elevation) +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) From 35c5881114bc404f1c0a575d6c1e7ab0f4187d18 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 19:54:47 +0800 Subject: [PATCH 36/46] Ignore pytest cache --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index aed0c9d..6611cc5 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,9 @@ # python cache __pycache__/ +# pytest +.pytest_cache/ + # epanet *.rpt *.opt From 6ebaa21a7caf5687e89b43b1a7d0308184658c6e Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 20:36:23 +0800 Subject: [PATCH 37/46] Return change set --- api/s0_base.py | 2 +- api/s7_valves.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/api/s0_base.py b/api/s0_base.py index e984143..6588846 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -123,7 +123,7 @@ def delete_node(name: str, node_type: str, id: str, table_sql: str, table_undo_s cur.execute(f"select * from coordinates where node = '{id}'") row = cur.fetchone() if row == None: - return + return ChangeSet() coord = row['coord'] diff --git a/api/s7_valves.py b/api/s7_valves.py index 496045c..7146562 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -75,11 +75,11 @@ def get_valve_minor_loss(name: str, id: str) -> float | 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 + return ChangeSet() row = _get_valve(name, id) if row == None: - return + return ChangeSet() return update(name, VALVE, 'valves', 'id', id, key, key_type, row[key], value, optional) From edd731904e584a1c28addd460da3c90ee767a7c3 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:02:53 +0800 Subject: [PATCH 38/46] Add tank test case --- test_tjnetwork.py | 100 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 99 insertions(+), 1 deletion(-) diff --git a/test_tjnetwork.py b/test_tjnetwork.py index 7d47a1a..c910181 100644 --- a/test_tjnetwork.py +++ b/test_tjnetwork.py @@ -113,6 +113,8 @@ class TestApi: 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 @@ -121,7 +123,103 @@ class TestApi: self.leave(p) def test_tank(self): - pass + 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" + + 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" + + tanks = get_nodes(p) + assert len(tanks) == 0 + + self.leave(p) def test_pipe(self): pass From 5dd83d7652c12b1bc62e7fd2598eed31ee426a40 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:18:17 +0800 Subject: [PATCH 39/46] Fix base bug --- api/s0_base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/api/s0_base.py b/api/s0_base.py index 6588846..a361435 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -43,7 +43,7 @@ def is_tank(name: str, id: str) -> bool: 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: From 939cef4f1e8bfcab43681ec2a039ba757afd5749 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:26:03 +0800 Subject: [PATCH 40/46] Add more checking for link api --- api/s5_pipes.py | 5 +++++ api/s6_pumps.py | 2 ++ api/s7_valves.py | 2 ++ 3 files changed, 9 insertions(+) diff --git a/api/s5_pipes.py b/api/s5_pipes.py index f9ca77c..63f36f8 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -14,6 +14,11 @@ def add_pipe(name: str, id: str, node1: str, node2: str, length: float = 0, diam 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}";' diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 6e7aefc..679bdac 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -9,6 +9,8 @@ def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet: 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}";' diff --git a/api/s7_valves.py b/api/s7_valves.py index 7146562..adea81a 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -17,6 +17,8 @@ def add_valve(name: str, id: str, node1: str, node2: str, diameter: float = 0, t return ChangeSet() if not is_node(name, node2): return ChangeSet() + if node1 == node2: + 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}";' From 2aa967546a6659334d1f1a10ba93f93b2ed54fc6 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:29:23 +0800 Subject: [PATCH 41/46] Check link node --- api/s5_pipes.py | 4 ++++ api/s6_pumps.py | 4 ++++ api/s7_valves.py | 4 ++++ 3 files changed, 12 insertions(+) diff --git a/api/s5_pipes.py b/api/s5_pipes.py index 63f36f8..b7b20c6 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -94,6 +94,8 @@ def _set_pipe(name: str, id: str, key: str, key_type: str, value: str, 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)) @@ -101,6 +103,8 @@ def set_pipe_node1(name: str, id: str, node1: str) -> ChangeSet: 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)) diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 679bdac..39eeb9e 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -67,6 +67,8 @@ def _set_pump(name: str, id: str, key: str, key_type: str, value: str, 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)) @@ -74,6 +76,8 @@ def set_pump_node1(name: str, id: str, node1: str) -> ChangeSet: 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)) diff --git a/api/s7_valves.py b/api/s7_valves.py index adea81a..f1f9a7c 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -89,6 +89,8 @@ def _set_valve(name: str, id: str, key: str, key_type: str, value: str, 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)) @@ -96,6 +98,8 @@ def set_valve_node1(name: str, id: str, node1: str) -> ChangeSet: 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)) From a645195eb5a304569ccee180ded5e8a48df0f8b2 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:34:27 +0800 Subject: [PATCH 42/46] Fix return type mismatch --- api/s5_pipes.py | 6 +++--- api/s6_pumps.py | 4 ++-- api/s7_valves.py | 6 +++--- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/api/s5_pipes.py b/api/s5_pipes.py index b7b20c6..471a7ee 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -47,12 +47,12 @@ def delete_pipe(name: str, id: str) -> ChangeSet: def get_pipe_node1(name: str, id: str) -> str | None: row = _get_pipe(name, id) - return float(row['node1']) if row != None else None + return row['node1'] if row != None else None def get_pipe_node2(name: str, id: str) -> str | None: row = _get_pipe(name, id) - return float(row['node2']) if row != None else None + return row['node2'] if row != None else None def get_pipe_length(name: str, id: str) -> float | None: @@ -77,7 +77,7 @@ def get_pipe_minor_loss(name: str, id: str) -> float | None: def get_pipe_status(name: str, id: str) -> str | None: row = _get_pipe(name, id) - return float(row['status']) if row != None else None + 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: diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 39eeb9e..7fa40ab 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -39,12 +39,12 @@ def delete_pump(name: str, id: str) -> ChangeSet: def get_pump_node1(name: str, id: str) -> str | None: row = _get_pump(name, id) - return float(row['node1']) if row != None else None + return row['node1'] if row != None else None def get_pump_node2(name: str, id: str) -> str | None: row = _get_pump(name, id) - return float(row['node2']) if row != None else None + return row['node2'] if row != None else None def get_pump_power(name: str, id: str) -> str | None: pass diff --git a/api/s7_valves.py b/api/s7_valves.py index f1f9a7c..3a8bace 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -47,12 +47,12 @@ def delete_valve(name: str, id: str) -> ChangeSet: def get_valve_node1(name: str, id: str) -> str | None: row = _get_valve(name, id) - return float(row['node1']) if row != None else None + return row['node1'] if row != None else None def get_valve_node2(name: str, id: str) -> str | None: row = _get_valve(name, id) - return float(row['node2']) if row != None else None + return row['node2'] if row != None else None def get_valve_diameter(name: str, id: str) -> float | None: @@ -62,7 +62,7 @@ def get_valve_diameter(name: str, id: str) -> float | None: def get_valve_type(name: str, id: str) -> str | None: row = _get_valve(name, id) - return float(row['type']) if row != None else None + return row['type'] if row != None else None def get_valve_setting(name: str, id: str) -> float | None: From 22e815cc6f7b47a8a11c13e52426372916d95ed7 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:48:20 +0800 Subject: [PATCH 43/46] Add pipe test case --- api/s0_base.py | 2 +- test_tjnetwork.py | 145 +++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 145 insertions(+), 2 deletions(-) diff --git a/api/s0_base.py b/api/s0_base.py index a361435..bedcd28 100644 --- a/api/s0_base.py +++ b/api/s0_base.py @@ -163,7 +163,7 @@ def add_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: def delete_link(name: str, link_type: str, id: str, table_sql: str, table_undo_sql: str) -> ChangeSet: - if not is_node(name, id): + if not is_link(name, id): return ChangeSet() with conn[name].cursor(row_factory=dict_row) as cur: diff --git a/test_tjnetwork.py b/test_tjnetwork.py index c910181..73d2629 100644 --- a/test_tjnetwork.py +++ b/test_tjnetwork.py @@ -62,6 +62,9 @@ class TestApi: 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" @@ -72,6 +75,9 @@ class TestApi: 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" @@ -95,6 +101,9 @@ class TestApi: 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 @@ -120,6 +129,9 @@ class TestApi: 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): @@ -137,6 +149,9 @@ class TestApi: 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' @@ -216,13 +231,141 @@ class TestApi: 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): - pass + 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): pass From ec3dff12b0a85955f07b29d5c6dbe0fe424f376e Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 22:57:42 +0800 Subject: [PATCH 44/46] Add pump test case --- api/s6_pumps.py | 2 +- test_tjnetwork.py | 81 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 82 insertions(+), 1 deletion(-) diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 7fa40ab..21d9569 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -12,7 +12,7 @@ def add_pump(name: str, id: str, node1: str, node2: str) -> ChangeSet: if node1 == node2: return ChangeSet() - sql = f"insert into pumps (id, node1, node2) values ('{id}', '{node1}', '{node2}'');" + 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) diff --git a/test_tjnetwork.py b/test_tjnetwork.py index 73d2629..6bdf309 100644 --- a/test_tjnetwork.py +++ b/test_tjnetwork.py @@ -368,6 +368,87 @@ class TestApi: 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) pass def test_valve(self): From 96c01d7fc87d0d4efd4ee12c180736ab77d3a8ca Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 23:09:43 +0800 Subject: [PATCH 45/46] Add valve test case --- api/s7_valves.py | 2 + test_tjnetwork.py | 120 +++++++++++++++++++++++++++++++++++++++++++++- tjnetwork.py | 2 +- 3 files changed, 121 insertions(+), 3 deletions(-) diff --git a/api/s7_valves.py b/api/s7_valves.py index 3a8bace..74d3fb4 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -19,6 +19,8 @@ def add_valve(name: str, id: str, node1: str, node2: str, diameter: float = 0, t 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}";' diff --git a/test_tjnetwork.py b/test_tjnetwork.py index 6bdf309..7ef7a28 100644 --- a/test_tjnetwork.py +++ b/test_tjnetwork.py @@ -449,10 +449,126 @@ class TestApi: assert change_set.deleted[0]['id'] == "p2" self.leave(p) - pass def test_valve(self): - pass + 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 diff --git a/tjnetwork.py b/tjnetwork.py index 9d8cddb..7e65944 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -369,7 +369,7 @@ 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_node1(name, valve_id) + 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) From 19917fe119addd64c0723edcb5ef9af44fd568a9 Mon Sep 17 00:00:00 2001 From: wqy Date: Sat, 17 Sep 2022 23:15:39 +0800 Subject: [PATCH 46/46] Remove coordinate api --- api/__init__.py | 2 +- tjnetwork.py | 11 ----------- 2 files changed, 1 insertion(+), 12 deletions(-) diff --git a/api/__init__.py b/api/__init__.py index 831eb98..59c1a33 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -46,4 +46,4 @@ 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 \ No newline at end of file +# from .s24_coordinates import get_node_coord, set_node_coord \ No newline at end of file diff --git a/tjnetwork.py b/tjnetwork.py index 7e65944..589e812 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -400,14 +400,3 @@ def set_valve_setting(name: str, valve_id: str, setting: float) -> ChangeSet: 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) - - -############################################################ -# coordinates 24.[COORDINATES] -############################################################ - -def get_node_coord(name: str, node_id: str) -> dict[str, float] | None: - return api.get_node_coord(name, node_id) - -def set_node_coord(name: str, node_id: str, x: float, y: float) -> ChangeSet: - return api.set_node_coord(name, node_id, x, y)