epyt-flow 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

epyt_flow/VERSION

@@ -1 +1 @@
-0.10.0
+0.12.0

epyt_flow/data/benchmarks/gecco_water_quality.py

@@ -17,9 +17,9 @@ import os
 from typing import Union
 import numpy as np
 import pandas as pd
+from sklearn.metrics import f1_score
 
 from ...utils import get_temp_folder, download_if_necessary
-from ...metrics import f1_score
 
 
 def compute_evaluation_score(y_pred: np.ndarray, y: np.ndarray) -> float:
@@ -41,7 +41,7 @@ def compute_evaluation_score(y_pred: np.ndarray, y: np.ndarray) -> float:
     `float`
         Evaluation score.
     """
-    return f1_score(y_pred, y)
+    return f1_score(y, y_pred)
 
 
 def load_gecco2017_water_quality_data(download_dir: str = None, return_X_y: bool = True,

epyt_flow/data/benchmarks/leakdb.py

@@ -13,8 +13,6 @@ This module provides functions for loading the original LeakDB data set
 The official scoring/evaluation is implemented in
 :func:`~epyt_flow.data.benchmarks.leakdb.compute_evaluation_score` -- i.e. those results can be
 directly compared to the official paper.
-Besides this, the user can choose to evaluate predictions using any other metric from
-:mod:`~epyt_flow.metrics`.
 """
 import os
 from typing import Union
@@ -24,12 +22,12 @@ import scipy
 import numpy as np
 import pandas as pd
 from scipy.sparse import bsr_array
+from sklearn.metrics import f1_score, recall_score as true_positive_rate
 
 from ..networks import load_net1, load_hanoi
 from .leakdb_data import NET1_LEAKAGES, HANOI_LEAKAGES
 from ...utils import get_temp_folder, to_seconds, unpack_zip_archive, create_path_if_not_exist, \
     download_if_necessary
-from ...metrics import f1_score, true_positive_rate, true_negative_rate
 from ...simulation import ScenarioSimulator, ToolkitConstants
 from ...simulation.events import AbruptLeakage, IncipientLeakage
 from ...simulation import ScenarioConfig
@@ -37,6 +35,43 @@ from ...simulation.scada import ScadaData
 from ...uncertainty import ModelUncertainty, UniformUncertainty
 
 
+def true_negative_rate(y_pred: np.ndarray, y: np.ndarray) -> float:
+    """
+    Computes the true negative rate (also called specificity).
+
+    Parameters
+    ----------
+    y_pred : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
+        Predicted labels.
+    y : `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
+        Ground truth labels.
+
+    Returns
+    -------
+    `float`
+        True negative rate.
+    """
+    if not isinstance(y_pred, np.ndarray):
+        raise TypeError("'y_pred' must be an instance of 'numpy.ndarray' " +
+                        f"but not of '{type(y_pred)}'")
+    if not isinstance(y, np.ndarray):
+        raise TypeError("'y' must be an instance of 'numpy.ndarray' " +
+                        f"but not of '{type(y)}'")
+    if y_pred.shape != y.shape:
+        raise ValueError(f"Shape mismatch: {y_pred.shape} vs. {y.shape}")
+    if len(y_pred.shape) > 1:
+        raise ValueError("'y_pred' must be a 1d array")
+    if len(y.shape) > 1:
+        raise ValueError("'y' must be a 1d array")
+    if set(np.unique(y_pred)) != set([0, 1]):
+        raise ValueError("Labels must be either '0' or '1'")
+
+    tn = np.sum((y == 0) & (y_pred == 0))
+    fp = np.sum((y == 0) & (y_pred == 1))
+
+    return tn / (tn + fp)
+
+
 def __leak_time_to_idx(t: int, round_up: bool = False, hydraulic_time_step: int = 1800):
     if round_up is False:
         return math.floor(t / hydraulic_time_step)
@@ -134,8 +169,8 @@ def compute_evaluation_score(scenarios_id: list[int], use_net1: bool,
     y_pred = np.stack(y_pred_labels_per_scenario, axis=0)
 
     # Evaluate predictions
-    f1 = f1_score(y_pred, y_true)
-    tpr = true_positive_rate(y_pred, y_true)
+    f1 = f1_score(y_true, y_pred)
+    tpr = true_positive_rate(y_true, y_pred)
     tnr = true_negative_rate(y_pred, y_true)
 
     early_detection_score = 0

epyt_flow/data/benchmarks/water_usage.py

@@ -4,9 +4,9 @@ Module provides a function for loading the water usage data set by P. Pavlou et
 import os
 import numpy as np
 import pandas as pd
+from sklearn.metrics import accuracy_score, precision_score, roc_auc_score, f1_score
 
 from ...utils import get_temp_folder, download_if_necessary
-from ...metrics import accuracy_score, precision_score, roc_auc_score, f1_micro_score
 
 
 def compute_evaluation_score(y_pred: np.ndarray, y: np.ndarray) -> dict:
@@ -32,8 +32,9 @@ def compute_evaluation_score(y_pred: np.ndarray, y: np.ndarray) -> dict:
     `dict`
         All evaluation scores.
     """
-    return {"accuracy": accuracy_score(y_pred, y), "precision": precision_score(y_pred, y),
-            "f1-micro": f1_micro_score(y_pred, y), "roc-auc": roc_auc_score(y_pred, y)}
+    return {"accuracy": accuracy_score(y, y_pred),
+            "precision": precision_score(y, y_pred, average="weighted"),
+            "f1-micro": f1_score(y, y_pred, average="micro"), "roc-auc": roc_auc_score(y, y_pred)}
 
 
 def load_water_usage(download_dir: str = None, return_X_y: bool = True, verbose: bool = True) -> dict:

epyt_flow/data/networks.py

@@ -154,8 +154,9 @@ def load_net1(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "Net1.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net1.inp"
+    backup_urls = ["https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/refs/heads/dev/epyt/networks/asce-tf-wdst/Net1.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -201,8 +202,9 @@ def load_net2(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "Net2.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net2.inp"
+    backup_urls = ["https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/refs/heads/dev/epyt/networks/asce-tf-wdst/Net2.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -248,8 +250,9 @@ def load_net3(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "Net3.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net3.inp"
+    backup_urls = ["https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/refs/heads/dev/epyt/networks/asce-tf-wdst/Net3.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -342,8 +345,9 @@ def load_richmond(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "Richmond_standard.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Richmond_standard.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/Richmond_standard.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -389,8 +393,9 @@ def load_micropolis(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "MICROPOLIS_v1.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/MICROPOLIS_v1.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/MICROPOLIS_v1.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -436,8 +441,9 @@ def load_balerma(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "Balerma.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Balerma.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/Balerma.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -483,8 +489,9 @@ def load_rural(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "RuralNetwork.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/RuralNetwork.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/RuralNetwork.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -530,8 +537,9 @@ def load_bwsn1(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "BWSN_Network_1.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/BWSN_Network_1.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/BWSN_Network_1.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -577,8 +585,9 @@ def load_bwsn2(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "BWSN_Network_2.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/BWSN_Network_2.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/BWSN_Network_2.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -624,8 +633,9 @@ def load_anytown(download_dir: str = get_temp_folder(), verbose: bool = True,
     """
     f_in = os.path.join(download_dir, "Anytown.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Anytown.inp"
+    backup_urls = ["https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/refs/heads/dev/epyt/networks/asce-tf-wdst/Anytown.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -670,9 +680,10 @@ def load_dtown(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "d-town.inp")
-    url = "https://www.exeter.ac.uk/media/universityofexeter/emps/research/cws/downloads/d-town.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/d-town.inp"
+    backup_urls = ["https://raw.githubusercontent.com/KIOS-Research/EPANET-Benchmarks/refs/heads/master/collect-epanet-inp/d-town.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -774,8 +785,9 @@ def load_kentucky(wdn_id: int = 1, download_dir: str = get_temp_folder(),
 
     f_in = os.path.join(download_dir, f"ky{wdn_id}.inp")
     url = f"https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/ky{wdn_id}.inp"
+    backup_urls = [f"https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/refs/heads/dev/epyt/networks/asce-tf-wdst/ky{wdn_id}.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     return load_inp(f_in, flow_units_id=flow_units_id)
 
 
@@ -826,8 +838,9 @@ def load_hanoi(download_dir: str = get_temp_folder(),
     """
     f_in = os.path.join(download_dir, "Hanoi.inp")
     url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Hanoi.inp"
+    backup_urls = ["https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/refs/heads/dev/epyt/networks/asce-tf-wdst/Hanoi.inp"]
 
-    download_if_necessary(f_in, url, verbose)
+    download_if_necessary(f_in, url, verbose, backup_urls)
     config = load_inp(f_in, flow_units_id=flow_units_id)
 
     if include_default_sensor_placement is True:

epyt_flow/gym/__init__.py

@@ -1,4 +1 @@
 from .scenario_control_env import *
-from .control_gyms import make, register
-
-# TODO: Register default environments

epyt_flow/gym/scenario_control_env.py

@@ -79,11 +79,13 @@ class ScenarioControlEnv(ABC):
             if self._sim_generator is not None:
                 next(self._sim_generator)
                 self._sim_generator.send(True)
+                self._sim_generator = None
         except StopIteration:
             pass
 
         if self._scenario_sim is not None:
             self._scenario_sim.close()
+            self._scenario_sim = None
 
     def contains_events(self) -> bool:
         """
@@ -106,16 +108,7 @@ class ScenarioControlEnv(ABC):
         :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
             Current SCADA data (i.e. sensor readings).
         """
-        if self._scenario_sim is not None:
-            # Abort current simulation if any is runing
-            try:
-                next(self._sim_generator)
-                self._sim_generator.send(True)
-            except StopIteration:
-                pass
-
-            # Close scenario
-            self._scenario_sim.close()
+        self.close()
 
         self._scenario_sim = ScenarioSimulator(
             scenario_config=self._scenario_config)
@@ -177,9 +170,14 @@ class ScenarioControlEnv(ABC):
             raise RuntimeError("Can not execute actions affecting the hydraulics "+
                                "when running EPANET-MSX")
 
-        pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
-        pump_link_idx = self._scenario_sim.epanet_api.getLinkPumpIndex(pump_idx + 1)
-        self._scenario_sim.epanet_api.setLinkStatus(pump_link_idx, status)
+        pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id) + 1
+        pump_link_idx = self._scenario_sim.epanet_api.getLinkPumpIndex(pump_idx)
+
+        pattern_idx = self._scenario_sim.epanet_api.getLinkPumpPatternIndex(pump_idx)
+        if pattern_idx != 0:
+            warnings.warn(f"Can not set pump state of pump {pump_id} because a pump pattern exists")
+        else:
+            self._scenario_sim.epanet_api.setLinkStatus(pump_link_idx, status)
 
     def set_pump_speed(self, pump_id: str, speed: float) -> None:
         """

epyt_flow/rest_api/scenario/control_handlers.py

@@ -0,0 +1,118 @@
+"""
+This module provides REST API handlers for complex and simple control modules of scenarios.
+"""
+import warnings
+import falcon
+
+from .handlers import ScenarioBaseHandler
+from ...simulation import ComplexControlModule, SimpleControlModule
+
+
+class ScenarioComplexControlHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning complex control modules.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets all complex control modules of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            my_simple_controls = self.scenario_mgr.get(scenario_id).complex_controls
+            self.send_json_response(resp, my_simple_controls)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Adds a new complex control module to a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#request>`_
+            Request instance.
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            complex_control = self.load_json_data_from_request(req)
+            if not isinstance(complex_control, ComplexControlModule):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).add_complex_control(complex_control)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
+class ScenarioSimpleControlHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning simple control modules.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets all simple control modules of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            my_simple_controls = self.scenario_mgr.get(scenario_id).simple_controls
+            self.send_json_response(resp, my_simple_controls)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Adds a new simple control module to a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#request>`_
+            Request instance.
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            simple_control = self.load_json_data_from_request(req)
+            if not isinstance(simple_control, SimpleControlModule):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).add_simple_control(simple_control)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR

epyt_flow/rest_api/scenario/event_handlers.py

@@ -5,7 +5,8 @@ import warnings
 import falcon
 
 from .handlers import ScenarioBaseHandler
-from ...simulation import Leakage, SensorFault
+from ...simulation import Leakage, SensorFault, SensorReadingAttack
+from ...simulation.events import SpeciesInjectionEvent
 
 
 class ScenarioLeakageHandler(ScenarioBaseHandler):
@@ -63,6 +64,118 @@ class ScenarioLeakageHandler(ScenarioBaseHandler):
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
 
 
+class ScenarioQualityEventHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning quality events.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets all quality events of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            my_system_events = self.scenario_mgr.get(scenario_id).system_events
+            my_quality_events = list(filter(lambda event: isinstance(event, SpeciesInjectionEvent),
+                                            my_system_events))
+            self.send_json_response(resp, my_quality_events)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Adds a new quality event to a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#request>`_
+            Request instance.
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            quality_event = self.load_json_data_from_request(req)
+            if not isinstance(quality_event, SpeciesInjectionEvent):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).add_system_event(quality_event)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
+class ScenarioSensorReadingAttackHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning sensor reading attacks.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets all sensor reading attack events of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            my_sensor_reading_attacks = self.scenario_mgr.get(scenario_id).sensor_reading_attacks
+            self.send_json_response(resp, my_sensor_reading_attacks)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Adds a new sensor reading attack event to a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#request>`_
+            Request instance.
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Response instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            sensor_reading_attack = self.load_json_data_from_request(req)
+            if not isinstance(sensor_reading_attack, SensorReadingAttack):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).add_sensor_reading_attack(sensor_reading_attack)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
 class ScenarioSensorFaultHandler(ScenarioBaseHandler):
     """
     Class for handling GET and POST requests concerning sensor faults.

epyt_flow/rest_api/scenario/handlers.py

@@ -278,6 +278,39 @@ class ScenarioGeneralParamsHandler(ScenarioBaseHandler):
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
 
 
+class ScenarioQualityParamsHandler(ScenarioBaseHandler):
+    """
+    Class for handling POST requests for specifying (EPANET) quality parameters of a given scenario.
+    """
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Specifies the (EPANET) quality parameters of a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#request>`_
+            Request instance.
+        resp : `falcon.Response <https://falcon.readthedocs.io/en/stable/api/request_and_response_asgi.html#response>`_
+            Request instance.
+        scenario_id : `str`
+            UUID of the scenario.
+        """
+        try:
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            quality_params = self.load_json_data_from_request(req)
+            if not isinstance(quality_params, dict):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).set_quality_parameters(**quality_params)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
 class ScenarioSensorConfigHandler(ScenarioBaseHandler):
     """
     Class for handling GET and POST requests for the sensor configuration of a given scenario.

epyt_flow/rest_api/server.py

@@ -7,10 +7,12 @@ import falcon
 from .scenario.handlers import ScenarioManager, ScenarioNewHandler, \
     ScenarioRemoveHandler, ScenarioGeneralParamsHandler, ScenarioSensorConfigHandler, \
     ScenarioExportHandler, ScenarioTopologyHandler, ScenarioConfigHandler, \
-    ScenarioNodeDemandPatternHandler
+    ScenarioNodeDemandPatternHandler, ScenarioQualityParamsHandler
 from .scenario.uncertainty_handlers import ScenarioModelUncertaintyHandler, \
     ScenarioSensorUncertaintyHandler
-from .scenario.event_handlers import ScenarioLeakageHandler, ScenarioSensorFaultHandler
+from .scenario.control_handlers import ScenarioSimpleControlHandler, ScenarioComplexControlHandler
+from .scenario.event_handlers import ScenarioLeakageHandler, ScenarioSensorFaultHandler, \
+    ScenarioQualityEventHandler, ScenarioSensorReadingAttackHandler
 from .scenario.simulation_handlers import ScenarioSimulationHandler, \
     ScenarioBasicQualitySimulationHandler, ScenarioAdvancedQualitySimulationHandler
 from .scada_data.handlers import ScadaDataManager, ScadaDataSensorConfigHandler, \
@@ -54,14 +56,24 @@ class RestApiService():
                            ScenarioConfigHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/general_params",
                            ScenarioGeneralParamsHandler(self.scenario_mgr))
+        self.app.add_route("/scenario/{scenario_id}/quality_params",
+                           ScenarioQualityParamsHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/sensor_config",
                            ScenarioSensorConfigHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/uncertainty/model",
                            ScenarioModelUncertaintyHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/uncertainty/sensors",
                            ScenarioSensorUncertaintyHandler(self.scenario_mgr))
+        self.app.add_route("/scenario/{scenario_id}/controls/simple",
+                           ScenarioSimpleControlHandler(self.scenario_mgr))
+        self.app.add_route("/scenario/{scenario_id}/controls/complex",
+                           ScenarioComplexControlHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/events/leakages",
                            ScenarioLeakageHandler(self.scenario_mgr))
+        self.app.add_route("/scenario/{scenario_id}/events/quality",
+                           ScenarioQualityEventHandler(self.scenario_mgr))
+        self.app.add_route("/scenario/{scenario_id}/events/sensor_reading_attacks",
+                           ScenarioSensorReadingAttackHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/events/sensor_faults",
                            ScenarioSensorFaultHandler(self.scenario_mgr))
         self.app.add_route("/scenario/{scenario_id}/node/{node_id}/demand_pattern",

epyt_flow/serialization.py

@@ -52,6 +52,7 @@ SIMPLE_CONTROL_ID                       = 32
 COMPLEX_CONTROL_ID                      = 33
 COMPLEX_CONTROL_CONDITION_ID            = 34
 COMPLEX_CONTROL_ACTION_ID               = 35
+COLOR_SCHEMES_ID                        = 36
 
 
 def my_packb(data: Any) -> bytes:

epyt_flow/simulation/__init__.py

@@ -1,5 +1,4 @@
 from .scenario_config import *
 from .sensor_config import *
 from .scenario_simulator import *
-from .scenario_visualizer import *
 from .parallel_simulation import *