epyt-flow 0.11.0__tar.gz → 0.13.0__tar.gz

{epyt_flow-0.11.0 → epyt_flow-0.13.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: epyt-flow
-Version: 0.11.0
+Version: 0.13.0
 Summary: EPyT-Flow -- EPANET Python Toolkit - Flow
 Author-email: André Artelt <aartelt@techfak.uni-bielefeld.de>, "Marios S. Kyriakou" <kiriakou.marios@ucy.ac.cy>, "Stelios G. Vrachimis" <vrachimis.stelios@ucy.ac.cy>
-License: MIT License
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/WaterFutures/EPyT-Flow
 Project-URL: Documentation, https://epyt-flow.readthedocs.io/en/stable/
 Project-URL: Repository, https://github.com/WaterFutures/EPyT-Flow.git
@@ -11,7 +11,6 @@ Project-URL: Issues, https://github.com/WaterFutures/EPyT-Flow/issues
 Keywords: epanet,water,networks,hydraulics,quality,simulations
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -35,6 +34,7 @@ Requires-Dist: geopandas>=0.14.4
 Requires-Dist: svgpath2mpl>=1.0.0
 Requires-Dist: Deprecated>=1.2.14
 Requires-Dist: psutil
+Dynamic: license-file
 
 [![pypi](https://img.shields.io/pypi/v/epyt-flow.svg)](https://pypi.org/project/epyt-flow/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

{epyt_flow-0.11.0 → epyt_flow-0.13.0}/epyt_flow/EPANET/EPANET-MSX/Src/msxtoolkit.c

@@ -203,7 +203,7 @@ int   MSXDLLEXPORT  MSXusehydfile(char *fname)
 // --- read length of simulation period covered by file
 
     fread(&n, sizeof(INT4), 1, MSX.HydFile.file);
-    MSX.Dur = 1000 * n;
+    MSX.Dur = INT64_C(1000) * n;
     MSX.HydOffset = ftell(MSX.HydFile.file);
     return 0;
 }

epyt_flow-0.13.0/epyt_flow/VERSION

@@ -0,0 +1 @@
+0.13.0

{epyt_flow-0.11.0 → epyt_flow-0.13.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-0.11.0 → epyt_flow-0.13.0}/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-0.11.0 → epyt_flow-0.13.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-0.13.0/epyt_flow/gym/__init__.py

@@ -0,0 +1 @@
+from .scenario_control_env import *

{epyt_flow-0.11.0 → epyt_flow-0.13.0}/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)
@@ -138,7 +131,7 @@ class ScenarioControlEnv(ABC):
     def _next_sim_itr(self) -> Union[tuple[ScadaData, bool], ScadaData]:
         try:
             next(self._sim_generator)
-            scada_data = self._sim_generator.send(False)
+            scada_data, terminated = self._sim_generator.send(False)
 
             if self._scenario_sim.f_msx_in is not None:
                 cur_time = int(scada_data.sensor_readings_time[0])
@@ -149,7 +142,7 @@ class ScenarioControlEnv(ABC):
             if self.autoreset is True:
                 return scada_data
             else:
-                return scada_data, False
+                return scada_data, terminated
         except StopIteration:
             if self.__autoreset is True:
                 return self.reset()

epyt_flow-0.11.0/epyt_flow/rest_api/scenario/event_handlers.py → epyt_flow-0.13.0/epyt_flow/rest_api/scenario/control_handlers.py

@@ -1,20 +1,20 @@
 """
-This module provides REST API handlers for scenario events.
+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 Leakage, SensorFault
+from ...simulation import ComplexControlModule, SimpleControlModule
 
 
-class ScenarioLeakageHandler(ScenarioBaseHandler):
+class ScenarioComplexControlHandler(ScenarioBaseHandler):
     """
-    Class for handling GET and POST requests concerning leakages.
+    Class for handling GET and POST requests concerning complex control modules.
     """
     def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
         """
-        Gets all leakages of a given scenario.
+        Gets all complex control modules of a given scenario.
 
         Parameters
         ----------
@@ -28,15 +28,15 @@ class ScenarioLeakageHandler(ScenarioBaseHandler):
                 self.send_invalid_resource_id_error(resp)
                 return
 
-            my_leakages = self.scenario_mgr.get(scenario_id).leakages
-            self.send_json_response(resp, my_leakages)
+            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 leakage to a given scenario.
+        Adds a new complex control module to a given scenario.
 
         Parameters
         ----------
@@ -52,24 +52,24 @@ class ScenarioLeakageHandler(ScenarioBaseHandler):
                 self.send_invalid_resource_id_error(resp)
                 return
 
-            leakage = self.load_json_data_from_request(req)
-            if not isinstance(leakage, Leakage):
+            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_leakage(leakage)
+            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 ScenarioSensorFaultHandler(ScenarioBaseHandler):
+class ScenarioSimpleControlHandler(ScenarioBaseHandler):
     """
-    Class for handling GET and POST requests concerning sensor faults.
+    Class for handling GET and POST requests concerning simple control modules.
     """
     def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
         """
-        Gets all sensor faults of a given scenario.
+        Gets all simple control modules of a given scenario.
 
         Parameters
         ----------
@@ -83,15 +83,15 @@ class ScenarioSensorFaultHandler(ScenarioBaseHandler):
                 self.send_invalid_resource_id_error(resp)
                 return
 
-            my_sensor_faults = self.scenario_mgr.get(scenario_id).sensor_faults
-            self.send_json_response(resp, my_sensor_faults)
+            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 sensor fault to a given scenario.
+        Adds a new simple control module to a given scenario.
 
         Parameters
         ----------
@@ -107,12 +107,12 @@ class ScenarioSensorFaultHandler(ScenarioBaseHandler):
                 self.send_invalid_resource_id_error(resp)
                 return
 
-            sensor_fault = self.load_json_data_from_request(req)
-            if not isinstance(sensor_fault, SensorFault):
+            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_sensor_fault(sensor_fault)
+            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-0.13.0/epyt_flow/rest_api/scenario/event_handlers.py

@@ -0,0 +1,231 @@
+"""
+This module provides REST API handlers for scenario events.
+"""
+import warnings
+import falcon
+
+from .handlers import ScenarioBaseHandler
+from ...simulation import Leakage, SensorFault, SensorReadingAttack
+from ...simulation.events import SpeciesInjectionEvent
+
+
+class ScenarioLeakageHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning leakages.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets all leakages 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_leakages = self.scenario_mgr.get(scenario_id).leakages
+            self.send_json_response(resp, my_leakages)
+        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 leakage 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
+
+            leakage = self.load_json_data_from_request(req)
+            if not isinstance(leakage, Leakage):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).add_leakage(leakage)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            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.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets all sensor faults 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_faults = self.scenario_mgr.get(scenario_id).sensor_faults
+            self.send_json_response(resp, my_sensor_faults)
+        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 fault 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_fault = self.load_json_data_from_request(req)
+            if not isinstance(sensor_fault, SensorFault):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).add_sensor_fault(sensor_fault)
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR

{epyt_flow-0.11.0 → epyt_flow-0.13.0}/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-0.11.0 → epyt_flow-0.13.0}/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-0.13.0/epyt_flow/simulation/backend/__init__.py

@@ -0,0 +1 @@
+from .my_epyt import *