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

epyt_flow/VERSION

@@ -1 +1 @@
-0.11.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/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)

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/simulation/backend/__init__.py

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