Refine node getter api

api/__init__.py

@@ -16,21 +16,22 @@ from .s0_base import is_link, is_pipe, is_pump, is_valve
 from .s0_base import is_curve
 from .s0_base import is_pattern
 from .s0_base import get_nodes, get_links, get_curves, get_patterns
+from .s0_base import get_node_links
 
 from .s1_title import set_title, get_title
 
 from .s2_junctions import add_junction, delete_junction
-from .s2_junctions import get_junction_elevation, get_junction_demand, get_junction_pattern, get_junction_coord
 from .s2_junctions import set_junction_elevation, set_junction_demand, set_junction_pattern, set_junction_coord
+from .s2_junctions import get_junction_property_names, get_junction_properties
 
 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 .s3_reservoirs import get_reservoir_property_names, get_reservoir_properties
 
 from .s4_tanks import OVERFLOW_YES, OVERFLOW_NO
 from .s4_tanks import add_tank, delete_tank
-from .s4_tanks import get_tank_elevation, get_tank_init_level, get_tank_min_level, get_tank_max_level, get_tank_diameter, get_tank_min_vol, get_tank_vol_curve, get_tank_overflow, get_tank_coord
 from .s4_tanks import set_tank_elevation, set_tank_init_level, set_tank_min_level, set_tank_max_level, set_tank_diameter, set_tank_min_vol, set_tank_vol_curve, set_tank_overflow, set_tank_coord
+from .s4_tanks import get_tank_property_names, get_tank_properties
 
 from .s5_pipes import PIPE_STATUS_OPEN, PIPE_STATUS_CLOSED, PIPE_STATUS_CV
 from .s5_pipes import add_pipe, delete_pipe

api/s2_junctions.py

@@ -1,3 +1,4 @@
+from typing import Any
 from psycopg.rows import Row
 from .s0_base import *
 from .change_set import ChangeSet
@@ -33,31 +34,6 @@ def delete_junction(name: str, id: str) -> ChangeSet:
     return delete_node(name, JUNCTION, id, sql, undo_sql)
 
 
-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:
-        return float(row['demand']) if row['demand'] != None else 'NULL'
-    else:
-        return None
-
-
-def get_junction_pattern(name: str, id: str) -> str | None:
-    row = _get_junction(name, id)
-    if row != None:
-        return row['pattern'] if row['pattern'] != None else 'NULL'
-    else:
-        return None
-
-
-def get_junction_coord(name: str, id: str) -> dict[str, float] | None:
-    return get_node_coord(name, id)
-
-
 def _set_junction(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
     if not is_junction(name, id):
         return ChangeSet()
@@ -89,3 +65,21 @@ def set_junction_coord(name: str, id: str, x: float, y: float) -> ChangeSet:
         return ChangeSet()
 
     return set_node_coord(name, JUNCTION, id, x, y)
+
+
+def get_junction_property_names(name: str) -> list[str]:
+    return ['elevation', 'demand', 'pattern', 'coord', 'links']
+
+
+def get_junction_properties(name: str, id: str) -> dict[str, Any] | None:
+    row = _get_junction(name, id)
+    if row == None:
+        return None
+
+    ps: dict[str, str] = {}
+    ps['elevation'] = float(row['elevation'])
+    ps['demand'] = float(row['demand']) if row != None and row['demand'] != None else None 
+    ps['pattern'] = row['pattern'] if row != None and row['pattern'] != None else None
+    ps['coord'] = get_node_coord(name, id)
+    ps['links'] = get_node_links(name, id)
+    return ps

api/s3_reservoirs.py

@@ -1,3 +1,4 @@
+from typing import Any
 from psycopg.rows import Row
 from .s0_base import *
 from .change_set import ChangeSet
@@ -32,23 +33,6 @@ def delete_reservoir(name: str, id: str) -> ChangeSet:
     return delete_node(name, RESERVOIR, id, sql, undo_sql)
 
 
-def get_reservoir_head(name: str, id: str) -> float | None:
-    row = _get_reservoir(name, id)
-    return float(row['head']) if row != None else None
-
-
-def get_reservoir_pattern(name: str, id: str) -> str | None:
-    row = _get_reservoir(name, id)
-    if row != None:
-        return row['pattern'] if row['pattern'] != None else 'NULL'
-    else:
-        return None
-
-
-def get_reservoir_coord(name: str, id: str) -> dict[str, float] | None:
-    return get_node_coord(name, id)
-
-
 def _set_reservoir(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
     if not is_reservoir(name, id):
         return ChangeSet()
@@ -76,3 +60,20 @@ def set_reservoir_coord(name: str, id: str, x: float, y: float) -> ChangeSet:
         return ChangeSet()
 
     return set_node_coord(name, RESERVOIR, id, x, y)
+
+
+def get_reservoir_property_names(name: str) -> list[str]:
+    return ['head', 'pattern', 'coord']
+
+
+def get_reservoir_properties(name: str, id: str) -> dict[str, Any] | None:
+    row = _get_reservoir(name, id)
+    if row == None:
+        return None
+
+    ps: dict[str, str] = {}
+    ps['head'] = float(row['head']) if row != None else None
+    ps['pattern'] = row['pattern'] if row != None and row['pattern'] != None else None
+    ps['coord'] = get_node_coord(name, id)
+    ps['links'] = get_node_links(name, id)
+    return ps

api/s4_tanks.py

@@ -1,3 +1,4 @@
+from typing import Any
 from psycopg.rows import Row
 from .s0_base import *
 from .change_set import ChangeSet
@@ -42,56 +43,6 @@ def delete_tank(name: str, id: str) -> ChangeSet:
     return delete_node(name, TANK, id, sql, undo_sql)
 
 
-def get_tank_elevation(name: str, id: str) -> float | None:
-    row = _get_tank(name, id)
-    return float(row['elevation']) if row != None else None
-
-
-def get_tank_init_level(name: str, id: str) -> float | None:
-    row = _get_tank(name, id)
-    return float(row['init_level']) if row != None else None
-
-
-def get_tank_min_level(name: str, id: str) -> float | None:
-    row = _get_tank(name, id)
-    return float(row['min_level']) if row != None else None
-
-
-def get_tank_max_level(name: str, id: str) -> float | None:
-    row = _get_tank(name, id)
-    return float(row['max_level']) if row != None else None
-
-
-def get_tank_diameter(name: str, id: str) -> float | None:
-    row = _get_tank(name, id)
-    return float(row['diameter']) if row != None else None
-
-
-def get_tank_min_vol(name: str, id: str) -> float | None:
-    row = _get_tank(name, id)
-    return float(row['min_vol']) if row != None else None
-
-
-def get_tank_vol_curve(name: str, id: str) -> str | None:
-    row = _get_tank(name, id)
-    if row != None:
-        return row['vol_curve'] if row['vol_curve'] != None else 'NULL'
-    else:
-        return None
-
-
-def get_tank_overflow(name: str, id: str) -> str | None:
-    row = _get_tank(name, id)
-    if row != None:
-        return row['overflow'] if row['overflow'] != None else 'NULL'
-    else:
-        return None
-
-
-def get_tank_coord(name: str, id: str) -> dict[str, float] | None:
-    return get_node_coord(name, id)
-
-
 def _set_tank(name: str, id: str, key: str, key_type: str, value: str, optional: bool = False) -> ChangeSet:
     if not is_tank(name, id):
         return ChangeSet()
@@ -146,3 +97,25 @@ def set_tank_coord(name: str, id: str, x: float, y: float) -> ChangeSet:
         return ChangeSet()
 
     return set_node_coord(name, TANK, id, x, y)
+
+
+def get_tank_property_names(name: str) -> list[str]:
+    return ['elevation', 'init_level', 'min_level', 'max_level', 'diameter', 'min_vol', 'vol_curve', 'overflow', 'coord']
+
+
+def get_tank_properties(name: str, id: str) -> dict[str, Any] | None:
+    row = _get_tank(name, id)
+    if row == None:
+        return None
+
+    ps: dict[str, str] = {}
+    ps['elevation'] = float(row['elevation']) if row != None else None
+    ps['init_level'] = float(row['init_level']) if row != None else None
+    ps['min_level'] = float(row['min_level']) if row != None else None
+    ps['max_level'] = float(row['max_level']) if row != None else None
+    ps['diameter'] = float(row['diameter']) if row != None else None
+    ps['min_vol'] = float(row['min_vol']) if row != None else None
+    ps['vol_curve'] = row['vol_curve'] if row != None and row['vol_curve'] != None else None
+    ps['overflow'] = row['overflow'] if row != None and row['overflow'] != None else None
+    ps['coord'] = get_node_coord(name, id)
+    return ps

test_tjnetwork.py

@@ -74,6 +74,7 @@ class TestApi:
 
         self.leave(p)
 
+
     def test_junction(self):
         p = "test_junction"
         self.enter(p)
@@ -83,21 +84,22 @@ class TestApi:
         assert change_set.operations[0]['operation'] == 'add'
         assert change_set.operations[0]['type'] == JUNCTION
         assert change_set.operations[0]['id'] == "j0"
-        coord = get_junction_coord(p, 'j0')
+        coord = get_junction_properties(p, 'j0')['coord']
         assert coord['x'] == 0.0
         assert coord['y'] == 10.0
-        z = get_junction_elevation(p, 'j0')
+        z = get_junction_properties(p, 'j0')['elevation']
         assert z == 20.0
 
-        assert get_junction_demand(p, 'j') == None
+        assert get_junction_properties(p, 'j') == None
-        assert get_junction_demand(p, 'j0') == "NULL"
+        assert get_junction_properties(p, 'j0')['demand'] == None
+        assert get_junction_properties(p, 'j0')['demand'] == None
         change_set = set_junction_demand(p, 'j0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == JUNCTION
         assert change_set.operations[0]['id'] == 'j0'
         assert change_set.operations[0]['property'] == 'demand'
-        assert get_junction_demand(p, 'j0') == 100.0
+        assert get_junction_properties(p, 'j0')['demand'] == 100.0
 
         # TODO: pattern
 
@@ -137,8 +139,19 @@ class TestApi:
         nodes = get_nodes(p)
         assert len(nodes) == 0
 
+        add_junction(p, 'j1', 0.0, 0.0, 0.0)
+        add_junction(p, 'j2', 10.0, 10.0, 10.0)
+        add_junction(p, 'j3', 10.0, 10.0, 10.0)
+        add_pipe(p, 'p1', 'j1', 'j2')
+        add_pump(p, 'p2', 'j1', 'j2')
+        add_valve(p, 'v1', 'j2', 'j3')
+        assert get_junction_properties(p, 'j1')['links'] == ['p1', 'p2']
+        assert get_junction_properties(p, 'j2')['links'] == ['p1', 'p2', 'v1']
+        assert get_junction_properties(p, 'j3')['links'] == ['v1']
+
         self.leave(p)
 
+
     def test_reservoir(self):
         p = "test_reservoir"
         self.enter(p)
@@ -152,19 +165,21 @@ class TestApi:
         change_set = add_reservoir(p, "r0", 0.0, 10.0, 20.0)
         assert len(change_set.operations) == 0
 
-        assert get_reservoir_head(p, 'r0') == 20.0
+        assert get_reservoir_properties(p, 'r0')['head'] == 20.0
+        assert get_reservoir_properties(p, 'r0')['head'] == 20.0
         change_set = set_reservoir_head(p, 'r0', 100.0)
         assert change_set.operations[0]['type'] == RESERVOIR
         assert change_set.operations[0]['id'] == 'r0'
         assert change_set.operations[0]['property'] == 'head'
-        assert get_reservoir_head(p, 'r0') == 100.0
+        assert get_reservoir_properties(p, 'r0')['head'] == 100.0
 
-        assert get_reservoir_coord(p, 'r0') == { 'x': 0.0, 'y': 10.0 }
+        assert get_reservoir_properties(p, 'r0')['coord'] == { 'x': 0.0, 'y': 10.0 }
+        assert get_reservoir_properties(p, 'r0')['coord'] == { 'x': 0.0, 'y': 10.0 }
         change_set = set_reservoir_coord(p, 'r0', 100.0, 200.0)
         assert change_set.operations[0]['type'] == RESERVOIR
         assert change_set.operations[0]['id'] == 'r0'
         assert change_set.operations[0]['property'] == 'coord'
-        assert get_reservoir_coord(p, 'r0') == { 'x': 100.0, 'y': 200.0 }
+        assert get_reservoir_properties(p, 'r0')['coord'] == { 'x': 100.0, 'y': 200.0 }
 
         # TODO: pattern
 
@@ -179,6 +194,7 @@ class TestApi:
 
         self.leave(p)
 
+
     def test_tank(self):
         p = "test_tank"
 
@@ -204,64 +220,64 @@ class TestApi:
         assert tanks[0] == 't0'
         assert tanks[1] == 't1'
 
-        assert get_tank_elevation(p, 't0') == 10.0
+        assert get_tank_properties(p, 't0')['elevation'] == 10.0
         change_set = set_tank_elevation(p, 't0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'elevation'
-        assert get_tank_elevation(p, 't0') == 100.0
+        assert get_tank_properties(p, 't0')['elevation'] == 100.0
 
-        assert get_tank_init_level(p, 't0') == 10.0
+        assert get_tank_properties(p, 't0')['init_level'] == 10.0
         change_set = set_tank_init_level(p, 't0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'init_level'
-        assert get_tank_init_level(p, 't0') == 100.0
+        assert get_tank_properties(p, 't0')['init_level'] == 100.0
 
-        assert get_tank_min_level(p, 't0') == 10.0
+        assert get_tank_properties(p, 't0')['min_level'] == 10.0
         change_set = set_tank_min_level(p, 't0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'min_level'
-        assert get_tank_min_level(p, 't0') == 100.0
+        assert get_tank_properties(p, 't0')['min_level'] == 100.0
 
-        assert get_tank_max_level(p, 't0') == 10.0
+        assert get_tank_properties(p, 't0')['max_level'] == 10.0
         change_set = set_tank_max_level(p, 't0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'max_level'
-        assert get_tank_max_level(p, 't0') == 100.0
+        assert get_tank_properties(p, 't0')['max_level'] == 100.0
 
-        assert get_tank_diameter(p, 't0') == 10.0
+        assert get_tank_properties(p, 't0')['diameter'] == 10.0
         change_set = set_tank_diameter(p, 't0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'diameter'
-        assert get_tank_diameter(p, 't0') == 100.0
+        assert get_tank_properties(p, 't0')['diameter'] == 100.0
 
-        assert get_tank_min_vol(p, 't0') == 10.0
+        assert get_tank_properties(p, 't0')['min_vol'] == 10.0
         change_set = set_tank_min_vol(p, 't0', 100.0)
         assert len(change_set.operations) == 1
         assert change_set.operations[0]['operation'] == 'update'
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'min_vol'
-        assert get_tank_min_vol(p, 't0') == 100.0
+        assert get_tank_properties(p, 't0')['min_vol'] == 100.0
 
         # TODO: vol_curve
 
-        assert get_tank_overflow(p, 't') == None
+        assert get_tank_properties(p, 't') == None
-        assert get_tank_overflow(p, 't0') == 'NULL'
+        assert get_tank_properties(p, 't0')['overflow'] == None
         change_set = set_tank_overflow(p, 't0', "XXX")
         assert len(change_set.operations) == 0
         change_set = set_tank_overflow(p, 't0', OVERFLOW_YES)
@@ -270,7 +286,7 @@ class TestApi:
         assert change_set.operations[0]['type'] == TANK
         assert change_set.operations[0]['id'] == "t0"
         assert change_set.operations[0]['property'] == 'overflow'
-        assert get_tank_overflow(p, 't0') == OVERFLOW_YES
+        assert get_tank_properties(p, 't0')['overflow'] == OVERFLOW_YES
 
         change_set = delete_tank(p, "t0")
         assert len(change_set.operations) == 1
@@ -295,6 +311,7 @@ class TestApi:
 
         self.leave(p)
 
+
     def test_pipe(self):
         p = "test_pipe"
         self.enter(p)
@@ -434,6 +451,7 @@ class TestApi:
 
         self.leave(p)
 
+
     def test_pump(self):
         p = "test_pump"
         self.enter(p)
@@ -523,6 +541,7 @@ class TestApi:
 
         self.leave(p)
 
+
     def test_valve(self):
         p = "test_valve"
         self.enter(p)

tjnetwork.py

@@ -1,3 +1,4 @@
+from typing import Any
 import api
 
 
@@ -166,18 +167,6 @@ def add_junction(name: str, junction_id: str, x: float, y: float, elevation: flo
 def delete_junction(name: str, junction_id: str) -> ChangeSet:
     return api.delete_junction(name, junction_id)
 
-def get_junction_elevation(name: str, junction_id: str) -> float | None:
-    return api.get_junction_elevation(name, junction_id)
-
-def get_junction_demand(name: str, junction_id: str) -> float | str | None:
-    return api.get_junction_demand(name, junction_id)
-
-def get_junction_pattern(name: str, junction_id: str) -> str | None:
-    return api.get_junction_pattern(name, junction_id)
-
-def get_junction_coord(name: str, junction_id: str) -> dict[str, float] | None:
-    return api.get_junction_coord(name, junction_id)
-
 def set_junction_elevation(name: str, junction_id: str, elevation: float) -> ChangeSet:
     return api.set_junction_elevation(name, junction_id, elevation)
 
@@ -190,6 +179,12 @@ 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)
 
+def get_junction_property_names(name: str) -> list[str]:
+    return api.get_junction_property_names(name)
+
+def get_junction_properties(name: str, id: str) -> dict[str, Any] | None:
+    return api.get_junction_properties(name, id)
+
 
 ############################################################
 # reservoir 3.[RESERVOIRS]
@@ -201,15 +196,6 @@ def add_reservoir(name: str, reservoir_id: str, x: float, y: float, head: float)
 def delete_reservoir(name: str, reservoir_id: str) -> ChangeSet:
     return api.delete_reservoir(name, reservoir_id)
 
-def get_reservoir_head(name: str, reservoir_id: str) -> float | None:
-    return api.get_reservoir_head(name, reservoir_id)
-
-def get_reservoir_pattern(name: str, reservoir_id: str) -> str | None:
-    return api.get_reservoir_pattern(name, reservoir_id)
-
-def get_reservoir_coord(name: str, reservoir_id: str) -> dict[str, float] | None:
-    return api.get_reservoir_coord(name, reservoir_id)
-
 def set_reservoir_head(name: str, reservoir_id: str, head: float) -> ChangeSet:
     return api.set_reservoir_head(name, reservoir_id, head)
 
@@ -219,6 +205,12 @@ def set_reservoir_pattern(name: str, reservoir_id: str, pattern: str) -> ChangeS
 def set_reservoir_coord(name: str, reservoir_id: str, x: float, y: float) -> ChangeSet:
     return api.set_reservoir_coord(name, reservoir_id, x, y)
 
+def get_reservoir_property_names(name: str) -> list[str]:
+    return api.get_reservoir_property_names(name)
+
+def get_reservoir_properties(name: str, id: str) -> dict[str, Any] | None:
+    return api.get_reservoir_properties(name, id)
+
 
 ############################################################
 # tank 4.[TANKS]
@@ -230,33 +222,6 @@ def add_tank(name: str, tank_id: str, x: float, y: float, elevation: float, init
 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)
 
@@ -284,6 +249,12 @@ 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)
 
+def get_tank_property_names(name: str) -> list[str]:
+    return api.get_tank_property_names(name)
+
+def get_tank_properties(name: str, id: str) -> dict[str, Any] | None:
+    return api.get_tank_properties(name, id)
+
 
 ############################################################
 # pipe 4.[PIPES]