epyt-flow 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

epyt_flow/rest_api/{scenario_handler.py → scenario/handlers.py}

@@ -1,13 +1,14 @@
 """
-This module provides all handlers for requests concerning scenarios.
+This module provides REST API handlers for some requests concerning scenarios.
 """
 import warnings
+import os
 import falcon
 
-from .base_handler import BaseHandler
-from .res_manager import ResourceManager
-from .scada_data_handler import ScadaDataManager
-from ..simulation import ScenarioSimulator, Leakage, SensorConfig
+from ..base_handler import BaseHandler
+from ..res_manager import ResourceManager
+from ...utils import get_temp_folder, pack_zip_archive
+from ...simulation import ScenarioSimulator, SensorConfig
 
 
 class ScenarioManager(ResourceManager):
@@ -36,7 +37,7 @@ class ScenarioBaseHandler(BaseHandler):
 
     Parameters
     ----------
-    scenario_mgr : :class:`~epyt_flow.rest_api.scenario_handler.ScenarioManager`
+    scenario_mgr : :class:`~epyt_flow.rest_api.scenario.handlers.ScenarioManager`
         Instance for managing all scenarios.
     """
     def __init__(self, scenario_mgr: ScenarioManager):
@@ -69,66 +70,85 @@ class ScenarioRemoveHandler(ScenarioBaseHandler):
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
 
 
-class ScenarioConfigHandler(ScenarioBaseHandler):
+class ScenarioExportHandler(ScenarioBaseHandler):
     """
-    Class for handling a GET request for getting the scenario configuration of a given scenario.
+    Class for handling GET requests for exporting a given scenario to EPANET files
+    -- i.e. .inp and (otpionally) .msx files.
     """
-    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+    def __create_temp_file_path(self, scenario_id: str, file_ext: str) -> None:
         """
-        Gets the scenario configuration of a given scenario.
+        Returns a path to a temporary file for storing the scenario.
 
         Parameters
         ----------
-        resp : `falcon.Response`
-            Response instance.
         scenario_id : `str`
             UUID of the scenario.
+        file_ext : `str`
+            File extension.
         """
-        try:
-            if self.scenario_mgr.validate_uuid(scenario_id) is False:
-                self.send_invalid_resource_id_error(resp)
-                return
+        return os.path.join(get_temp_folder(), f"{scenario_id}.{file_ext}")
 
-            my_sceanrio_config = self.scenario_mgr.get(scenario_id).get_scenario_config()
-            self.send_json_response(resp, my_sceanrio_config)
-        except Exception as ex:
-            warnings.warn(str(ex))
-            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+    def __send_temp_file(self, resp: falcon.Response, tmp_file: str,
+                         content_type: str = "application/octet-stream") -> None:
+        """
+        Sends a given file (`tmp_file`) to the the client.
 
+        Parameters
+        ----------
+        resp : `falcon.Response`
+            Response instance.
+        tmp_file : `str`
+            Path to the temporary file to be send.
+        """
+        resp.status = falcon.HTTP_200
+        resp.content_type = content_type
+        with open(tmp_file, 'rb') as f:
+            resp.text = f.read()
 
-class ScenarioNewHandler(ScenarioBaseHandler):
-    """
-    Class for handling POST requests for creating a new scenario.
-    """
-    def on_post(self, req: falcon.Request, resp: falcon.Response) -> None:
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
         """
-        Creates/Loads a new scenario.
+        Exports a given scenario to an .inp and (optionally) .msx file.
 
         Parameters
         ----------
-        req : `falcon.Request`
-            Request instance.
         resp : `falcon.Response`
             Response instance.
         scenario_id : `str`
             UUID of the scenario.
         """
         try:
-            args = self.load_json_data_from_request(req)
-            scenario_id = self.scenario_mgr.create(**args)
-            self.send_json_response(resp, {"scenario_id": scenario_id})
+            if self.scenario_mgr.validate_uuid(scenario_id) is False:
+                self.send_invalid_resource_id_error(resp)
+                return
+
+            my_scenario = self.scenario_mgr.get(scenario_id)
+
+            f_inp_out = self.__create_temp_file_path(scenario_id, "inp")
+            f_msx_out = self.__create_temp_file_path(scenario_id, "msx")
+            my_scenario.save_to_epanet_file(f_inp_out, f_msx_out)
+
+            if os.path.isfile(f_msx_out):
+                f_out = self.__create_temp_file_path(scenario_id, "zip")
+                pack_zip_archive([f_inp_out, f_msx_out], f_out)
+
+                self.__send_temp_file(resp, f_out)
+                os.remove(f_out)
+                os.remove(f_msx_out)
+            else:
+                self.__send_temp_file(resp, f_inp_out)
+            os.remove(f_inp_out)
         except Exception as ex:
             warnings.warn(str(ex))
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
 
 
-class ScenarioLeakageHandler(ScenarioBaseHandler):
+class ScenarioConfigHandler(ScenarioBaseHandler):
     """
-    Class for handling GET and POST requests concerning leakages.
+    Class for handling a GET request for getting the scenario configuration of a given scenario.
     """
     def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
         """
-        Gets all leakages of a given scenario.
+        Gets the scenario configuration of a given scenario.
 
         Parameters
         ----------
@@ -142,15 +162,20 @@ 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_sceanrio_config = self.scenario_mgr.get(scenario_id).get_scenario_config()
+            self.send_json_response(resp, my_sceanrio_config)
         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:
+
+class ScenarioNewHandler(ScenarioBaseHandler):
+    """
+    Class for handling POST requests for creating a new scenario.
+    """
+    def on_post(self, req: falcon.Request, resp: falcon.Response) -> None:
         """
-        Adds a new leakage to a given scenario.
+        Creates/Loads a new scenario.
 
         Parameters
         ----------
@@ -162,16 +187,9 @@ class ScenarioLeakageHandler(ScenarioBaseHandler):
             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)
+            args = self.load_json_data_from_request(req)
+            scenario_id = self.scenario_mgr.create(**args)
+            self.send_json_response(resp, {"scenario_id": scenario_id})
         except Exception as ex:
             warnings.warn(str(ex))
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
@@ -237,6 +255,8 @@ class ScenarioGeneralParamsHandler(ScenarioBaseHandler):
 
         Parameters
         ----------
+        req : `falcon.Request`
+            Request instance.
         resp : `falcon.Request`
             Request instance.
         scenario_id : `str`
@@ -290,6 +310,8 @@ class ScenarioSensorConfigHandler(ScenarioBaseHandler):
 
         Parameters
         ----------
+        req : `falcon.Request`
+            Request instance.
         resp : `falcon.Request`
             Request instance.
         scenario_id : `str`
@@ -312,41 +334,38 @@ class ScenarioSensorConfigHandler(ScenarioBaseHandler):
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
 
 
-class ScenarioSimulationHandler(ScenarioBaseHandler):
+class ScenarioNodeDemandPatternHandler(ScenarioBaseHandler):
     """
-    Class for handling GET requests for simulating a given scenario.
-
-    Parameters
-    ----------
-    scada_data_mgr : :class:`~epyt_flow.rest_api.scenario_handler.ScadaDataBaseHandler`
-        SCADA data manager.
+    Class for handling POST requests for node demand patterns of a given scenario.
     """
-    def __init__(self, scada_data_mgr: ScadaDataManager, **kwds):
-        self.scada_data_mgr = scada_data_mgr
-
-        super().__init__(**kwds)
-
-    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str,
+                node_id: str) -> None:
         """
-        Runs the simulation of a given scenario.
+        Sets the demand pattern of a specific node in a given scenario.
 
         Parameters
         ----------
+        req : `falcon.Request`
+            Request instance.
         resp : `falcon.Response`
             Response instance.
         scenario_id : `str`
             UUID of the scenario.
+        node_id : `str`
+            ID of the node.
         """
         try:
             if self.scenario_mgr.validate_uuid(scenario_id) is False:
                 self.send_invalid_resource_id_error(resp)
                 return
 
-            my_scenario = self.scenario_mgr.get(scenario_id)
-            res = my_scenario.run_simulation()
+            params = self.load_json_data_from_request(req)
 
-            data_id = self.scada_data_mgr.create_new_item(res)
-            self.send_json_response(resp, {"data_id": data_id})
+            my_scenario = self.scenario_mgr.get(scenario_id)
+            my_scenario.set_node_demand_pattern(node_id, params["base_demand"],
+                                                params["demand_pattern_id"],
+                                                params["demand_pattern"])
         except Exception as ex:
             warnings.warn(str(ex))
+            resp.data = str(ex)
             resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR

epyt_flow/rest_api/scenario/simulation_handlers.py

@@ -0,0 +1,174 @@
+"""
+This module provides REST API handlers concerning the simulation of scenarios.
+"""
+import warnings
+import falcon
+
+from .handlers import ScenarioBaseHandler
+from ..scada_data.handlers import ScadaDataManager
+
+
+class ScenarioSimulationHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET requests for simulating a given scenario.
+
+    Parameters
+    ----------
+    scada_data_mgr : :class:`~epyt_flow.rest_api.scada_data.handlers.ScadaDataManager`
+        SCADA data manager.
+    """
+    def __init__(self, scada_data_mgr: ScadaDataManager, **kwds):
+        self.scada_data_mgr = scada_data_mgr
+
+        super().__init__(**kwds)
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Runs the simulation of a given scenario.
+
+        Note that in contrat to the GET request
+        (:func:`~epyt_flow.rest_api.scenario.simulation_handlers.ScenarioSimulationHandler.on_get`),
+        the POST request allows to specify additional arguments passed to
+        :func:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator.run_simulation`.
+
+        Parameters
+        ----------
+        req : `falcon.Request`
+            Request instance.
+        resp : `falcon.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
+
+            params = self.load_json_data_from_request(req)
+
+            my_scenario = self.scenario_mgr.get(scenario_id)
+            res = my_scenario.run_simulation(**params)
+
+            data_id = self.scada_data_mgr.create_new_item(res)
+            self.send_json_response(resp, {"data_id": data_id})
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.data = str(ex)
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Runs the simulation of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.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_scenario = self.scenario_mgr.get(scenario_id)
+            res = my_scenario.run_simulation()
+
+            data_id = self.scada_data_mgr.create_new_item(res)
+            self.send_json_response(resp, {"data_id": data_id})
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.data = str(ex)
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
+class ScenarioBasicQualitySimulationHandler(ScenarioBaseHandler):
+    """
+    Class for handling POST requests for runing a basic quality simulation of a given scenario.
+
+    Parameters
+    ----------
+    scada_data_mgr : :class:`~epyt_flow.rest_api.scada_data.handlers.ScadaDataManager`
+        SCADA data manager.
+    """
+    def __init__(self, scada_data_mgr: ScadaDataManager, **kwds):
+        self.scada_data_mgr = scada_data_mgr
+
+        super().__init__(**kwds)
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Runs the basic quality simulation of a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request`
+            Request instance.
+        resp : `falcon.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
+
+            params = self.load_json_data_from_request(req)
+
+            my_scenario = self.scenario_mgr.get(scenario_id)
+            res = my_scenario.run_basic_quality_simulation(**params)
+
+            data_id = self.scada_data_mgr.create_new_item(res)
+            self.send_json_response(resp, {"data_id": data_id})
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.data = str(ex)
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
+class ScenarioAdvancedQualitySimulationHandler(ScenarioBaseHandler):
+    """
+    Class for handling POST requests for runing an advanced quality simulation of a given scenario.
+
+    Parameters
+    ----------
+    scada_data_mgr : :class:`~epyt_flow.rest_api.scada_data.handlers.ScadaDataManager`
+        SCADA data manager.
+    """
+    def __init__(self, scada_data_mgr: ScadaDataManager, **kwds):
+        self.scada_data_mgr = scada_data_mgr
+
+        super().__init__(**kwds)
+
+    def on_post(self, req: falcon.Request, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Runs the advanced quality simulation of a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request`
+            Request instance.
+        resp : `falcon.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
+
+            params = self.load_json_data_from_request(req)
+
+            my_scenario = self.scenario_mgr.get(scenario_id)
+            res = my_scenario.run_advanced_quality_simulation(**params)
+
+            data_id = self.scada_data_mgr.create_new_item(res)
+            self.send_json_response(resp, {"data_id": data_id})
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.data = str(ex)
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR

epyt_flow/rest_api/scenario/uncertainty_handlers.py

@@ -0,0 +1,118 @@
+"""
+This module provides REST API handlers for model and sensor uncertainties of scenarios.
+"""
+import warnings
+import falcon
+
+from .handlers import ScenarioBaseHandler
+from ...simulation import SensorNoise, ModelUncertainty
+
+
+class ScenarioModelUncertaintyHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning model uncertainty.
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets the model uncertainties of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.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_model_uncertainties = self.scenario_mgr.get(scenario_id).model_uncertainty
+            self.send_json_response(resp, my_model_uncertainties)
+        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:
+        """
+        Sets the model uncertainties of a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request`
+            Request instance.
+        resp : `falcon.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
+
+            model_uncertainty = self.load_json_data_from_request(req)
+            if not isinstance(model_uncertainty, ModelUncertainty):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).model_uncertainty = model_uncertainty
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR
+
+
+class ScenarioSensorUncertaintyHandler(ScenarioBaseHandler):
+    """
+    Class for handling GET and POST requests concerning sensor uncertainty (i.e. noise).
+    """
+    def on_get(self, _, resp: falcon.Response, scenario_id: str) -> None:
+        """
+        Gets the sensor uncertainty (i.e. noise) of a given scenario.
+
+        Parameters
+        ----------
+        resp : `falcon.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_noise = self.scenario_mgr.get(scenario_id).sensor_noise
+            self.send_json_response(resp, my_sensor_noise)
+        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:
+        """
+        Sets the sensor uncertainty (i.e. noise) of a given scenario.
+
+        Parameters
+        ----------
+        req : `falcon.Request`
+            Request instance.
+        resp : `falcon.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_noise = self.load_json_data_from_request(req)
+            if not isinstance(sensor_noise, SensorNoise):
+                self.send_json_parsing_error(resp)
+                return
+
+            self.scenario_mgr.get(scenario_id).sensor_noise = sensor_noise
+        except Exception as ex:
+            warnings.warn(str(ex))
+            resp.status = falcon.HTTP_INTERNAL_SERVER_ERROR