epyt-flow 0.14.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

epyt_flow/uncertainty/model_uncertainty.py

@@ -4,8 +4,7 @@ Module provides a class for implementing model uncertainty.
 from typing import Optional
 from copy import deepcopy
 import warnings
-import epyt
-from epyt.epanet import ToolkitConstants
+from epanet_plus import EPyT, EpanetConstants
 import numpy as np
 
 from ..serialization import serializable, JsonSerializable, MODEL_UNCERTAINTY_ID
@@ -627,7 +626,7 @@ class ModelUncertainty(JsonSerializable):
             f"local_patterns: {self._local_patterns} " + \
             f"local_msx_patterns: {self._local_msx_patterns} + seed: {self.__seed}"
 
-    def undo(self, epanet_api: epyt.epanet) -> None:
+    def undo(self, epanet_api: EPyT) -> None:
         """
         Undo all applied uncertainties -- i.e, resets the properties to their original value.
 
@@ -636,278 +635,303 @@ class ModelUncertainty(JsonSerializable):
 
         Parameters
         ----------
-        epanet_api : `epyt.epanet <https://epanet-python-toolkit-epyt.readthedocs.io/en/stable/api.html#epyt.epanet.epanet>`_
+        epanet_api : `epanet_plus.EPyT <https://epanet-plus.readthedocs.io/en/stable/api.html#epanet_plus.epanet_toolkit.EPyT>`_
             Interface to EPANET and EPANET-MSX
         """
         if self.__cache_original is False:
             raise ValueError("Caching was disabled by the user")
 
         if self._cache_links_length is not None:
-            epanet_api.setLinkLength(self._cache_links_length)
+            for link_idx, link_len in zip(epanet_api.get_all_links_idx(),
+                                          self._cache_links_length):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_len)
 
         if self._cache_links_diameter is not None:
-            epanet_api.setLinkDiameter(self._cache_links_diameter)
+            for link_idx, link_diam in zip(epanet_api.get_all_links_idx(),
+                                           self._cache_links_diameter):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_diam)
 
         if self._cache_links_roughness_coeff is not None:
-            epanet_api.setLinkRoughnessCoeff(self._cache_links_roughness_coeff)
+            for link_idx, link_roughness in zip(epanet_api.get_all_links_idx(),
+                                                self._cache_links_roughness_coeff):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS, link_roughness)
 
         if self._cache_nodes_base_demand is not None:
             for node_idx in self._cache_nodes_base_demand.keys():
                 for demand_category, base_demand in self._cache_nodes_base_demand[node_idx].items():
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
+                    epanet_api.setbasedemand(node_idx, demand_category + 1, base_demand)
 
         if self._cache_nodes_demand_pattern is not None:
-            for pattern_id, demand_pattern in self._cache_nodes_demand_pattern.items():
-                for t, v in enumerate(demand_pattern):
-                    epanet_api.setPatternValue(pattern_id, t+1, v)
+            for pattern_idx, demand_pattern in self._cache_nodes_demand_pattern.items():
+                epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._cache_nodes_elevation is not None:
-            epanet_api.setNodeElevations(self._cache_nodes_elevation)
+            for node_idx, node_elev in zip(epanet_api.get_all_nodes_idx(),
+                                           self._cache_nodes_elevation):
+                epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION, node_elev)
 
         if self._cache_patterns is not None:
             for pattern_idx, pattern in self._cache_patterns.items():
-                epanet_api.setPattern(pattern_idx, pattern)
+                epanet_api.set_pattern(pattern_idx, pattern.tolist())
 
         if self._cache_msx_constants is not None:
-            epanet_api.setMSXConstantsValue(self._cache_msx_constants)
+            for constant_idx, constant_value in enumerate(self._cache_msx_constants):
+                epanet_api.MSXsetconstant(constant_idx + 1, constant_value)
 
         if self._cache_msx_links_parameters is not None:
             for pipe_idx, parameters_pipes_val in self._cache_msx_links_parameters.items():
-                epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes_val)
+                for param_idx, param_value in enumerate(parameters_pipes_val):
+                    epanet_api.MSXsetparameter(EpanetConstants.MSX_LINK, pipe_idx,
+                                               param_idx + 1, param_value)
 
         if self._cache_msx_tanks_parameters is not None:
             for tank_idx, parameters_tanks_val in self._cache_msx_tanks_parameters.items():
-                epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks_val)
+                for param_idx, param_value in enumerate(parameters_tanks_val):
+                    epanet_api.MSXsetparameter(EpanetConstants.MSX_NODE, tank_idx,
+                                               param_idx + 1, param_value)
 
         if self._cache_msx_patterns is not None:
             for pattern_idx, pattern in self._cache_msx_patterns:
-                epanet_api.setMSXPattern(pattern_idx, pattern)
+                epanet_api.MSXsetpattern(pattern_idx, pattern.tolist(), len(pattern))
 
-    def apply(self, epanet_api: epyt.epanet) -> None:
+    def apply(self, epanet_api: EPyT) -> None:
         """
         Applies the specified model uncertainties to the scenario.
 
         Parameters
         ----------
-        epanet_api : `epyt.epanet <https://epanet-python-toolkit-epyt.readthedocs.io/en/stable/api.html#epyt.epanet.epanet>`_
+        epanet_api : `epanet_plus.EPyT <https://epanet-plus.readthedocs.io/en/stable/api.html#epanet_plus.epanet_toolkit.EPyT>`_
             Interface to EPANET and EPANET-MSX.
         """
         np_rand_gen = np.random.default_rng(seed=self.__seed)
 
+        all_links_idx = epanet_api.get_all_links_idx()
+        all_nodes_idx = epanet_api.get_all_nodes_idx()
+
         if self._global_pipe_length is not None:
             self._global_pipe_length.set_random_generator(np_rand_gen)
 
-            link_length = epanet_api.getLinkLength()
+            link_length = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
+                                    for link_idx in all_links_idx])
             self._cache_links_length = np.copy(link_length)
 
             link_length = self._global_pipe_length.apply_batch(link_length)
-            epanet_api.setLinkLength(link_length)
+            for link_idx, link_value in zip(all_links_idx, link_length):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_value)
 
         if self._local_pipe_length is not None:
             self._local_pipe_length.set_random_generator(np_rand_gen)
-            self._cache_links_length = epanet_api.getLinkLength()
+            self._cache_links_length = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
+                                                 for link_idx in all_links_idx])
 
             for pipe_id, uncertainty in self._local_pipe_length.items():
-                link_idx = epanet_api.getLinkIndex(pipe_id)
-                link_length = epanet_api.getLinkLength(link_idx)
+                link_idx = epanet_api.get_link_idx(pipe_id)
+                link_length = epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
 
                 link_length = uncertainty.apply(link_length)
-                epanet_api.setLinkLength(link_idx, link_length)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_length)
 
         if self._global_pipe_diameter is not None:
             self._global_pipe_diameter.set_random_generator(np_rand_gen)
 
-            link_diameters = epanet_api.getLinkDiameter()
+            link_diameters = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_DIAMETER)
+                                       for link_idx in all_links_idx])
             self._cache_links_diameter = np.copy(link_diameters)
 
             link_diameters = self._global_pipe_diameter.apply_batch(link_diameters)
-            epanet_api.setLinkDiameter(link_diameters)
+            for link_idx, link_value in zip(all_links_idx, link_diameters):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_value)
 
         if self._local_pipe_diameter is not None:
             self._local_pipe_diameter.set_random_generator(np_rand_gen)
-            self._cache_links_diameter = epanet_api.getLinkDiameter()
+            self._cache_links_diameter = np.array([epanet_api.getlinkvalue(link_idx,
+                                                                           EpanetConstants.EN_DIAMETER)
+                                                   for link_idx in all_links_idx])
 
             for pipe_id, uncertainty in self._local_pipe_diameter.items():
-                link_idx = epanet_api.getLinkIndex(pipe_id)
-                link_diameter = epanet_api.getLinkDiameter(link_idx)
+                link_idx = epanet_api.get_link_idx(pipe_id)
+                link_diameter = epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_DIAMETER)
 
                 link_diameter = uncertainty.apply(link_diameter)
-                epanet_api.setLinkDiameter(link_idx, link_diameter)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_diameter)
 
         if self._global_pipe_roughness is not None:
             self._global_pipe_roughness.set_random_generator(np_rand_gen)
 
-            coeffs = epanet_api.getLinkRoughnessCoeff()
+            coeffs = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS)
+                               for link_idx in all_links_idx])
             self._cache_links_roughness_coeff = np.copy(coeffs)
 
             coeffs = self._global_pipe_roughness.apply_batch(coeffs)
-            epanet_api.setLinkRoughnessCoeff(coeffs)
+            for link_idx, link_value in zip(all_links_idx, coeffs):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS, link_value)
 
         if self._local_pipe_roughness is not None:
             self._local_pipe_roughness.set_random_generator(np_rand_gen)
-            self._cache_links_roughness_coeff = epanet_api.getLinkRoughnessCoeff()
+            self._cache_links_roughness_coeff = \
+                np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS)
+                          for link_idx in all_links_idx])
 
             for pipe_id, uncertainty in self._local_pipe_roughness.items():
-                link_idx = epanet_api.getLinkIndex(pipe_id)
-                link_roughness_coeff = epanet_api.getLinkRoughnessCoeff(link_idx)
+                link_idx = epanet_api.get_link_idx(pipe_id)
+                link_roughness_coeff = epanet_api.getlinkvalue(link_idx,
+                                                               EpanetConstants.EN_ROUGHNESS)
 
                 link_roughness_coeff = uncertainty.apply(link_roughness_coeff)
-                epanet_api.setLinkRoughnessCoeff(link_idx, link_roughness_coeff)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS,
+                                        link_roughness_coeff)
 
         if self._global_base_demand is not None:
             self._global_base_demand.set_random_generator(np_rand_gen)
 
             self._cache_nodes_base_demand = {}
-            all_nodes_idx = epanet_api.getNodeIndex()
             for node_idx in all_nodes_idx:
                 self._cache_nodes_base_demand[node_idx] = {}
-                n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
-                for demand_category in range(n_demand_categories):
-                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category + 1]
-                    self._cache_nodes_base_demand[node_idx][demand_category] = base_demand
+                n_demand_categories = epanet_api.getnumdemands(node_idx)
+                for demand_idx in range(n_demand_categories):
+                    base_demand = epanet_api.getbasedemand(node_idx, demand_idx + 1)
+                    self._cache_nodes_base_demand[node_idx][demand_idx] = base_demand
 
                     base_demand = self._global_base_demand.apply(base_demand)
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
+                    epanet_api.setbasedemand(node_idx, demand_idx + 1, base_demand)
 
         if self._local_base_demand is not None:
             self._local_base_demand.set_random_generator(np_rand_gen)
 
             self._cache_nodes_base_demand = {}
             for node_id, uncertainty in self._local_base_demand.items():
-                node_idx = epanet_api.getNodeIndex(node_id)
+                node_idx = epanet_api.get_node_idx(node_id)
                 self._cache_nodes_base_demand[node_idx] = {}
-                n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
-                for demand_category in range(n_demand_categories):
-                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category + 1]
-                    self._cache_nodes_base_demand[node_idx][demand_category] = base_demand
+                n_demand_categories = epanet_api.getnumdemands(node_idx)
+                for demand_idx in range(n_demand_categories):
+                    base_demand = epanet_api.getbasedemand(node_idx, demand_idx + 1)
+                    self._cache_nodes_base_demand[node_idx][demand_idx] = base_demand
 
                     base_demand = uncertainty.apply(base_demand)
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
+                    epanet_api.setbasedemand(node_idx, demand_idx + 1, base_demand)
 
         if self._global_demand_pattern is not None:
             self._global_demand_pattern.set_random_generator(np_rand_gen)
 
             self._cache_nodes_demand_pattern = {}
-            demand_patterns_idx = epanet_api.getNodeDemandPatternIndex()
-            demand_patterns_id = np.unique([demand_patterns_idx[k]
-                                            for k in demand_patterns_idx.keys()])
-            for pattern_id in demand_patterns_id:
-                if pattern_id == 0:
-                    continue
-
-                pattern_length = epanet_api.getPatternLengths(pattern_id)
-                demand_pattern = np.zeros(pattern_length)
-
-                for t in range(pattern_length):
-                    v = epanet_api.getPatternValue(pattern_id, t+1)
-                    demand_pattern[t] = v
+            demand_patterns_idx = np.array([epanet_api.getdemandpattern(node_idx, demand_idx + 1)
+                                            for node_idx in epanet_api.get_all_nodes_idx()
+                                            for demand_idx in range(epanet_api.getnumdemands(node_idx))])
 
-                    v_ = self._global_demand_pattern.apply(v)
-                    epanet_api.setPatternValue(pattern_id, t+1, v_)
+            for pattern_idx in list(set(demand_patterns_idx)):
+                demand_pattern = np.array(epanet_api.get_pattern(pattern_idx))
+                self._cache_nodes_demand_pattern[pattern_idx] = np.copy(demand_pattern)
 
-                self._cache_nodes_demand_pattern[pattern_id] = demand_pattern
+                demand_pattern = self._global_demand_pattern.apply_batch(demand_pattern)
+                epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._local_demand_pattern is not None:
             self._local_demand_pattern.set_random_generator(np_rand_gen)
 
             self._cache_nodes_demand_pattern = {}
-            patterns_id = epanet_api.getPatternNameID()
-            paterns_idx = epanet_api.getPatternIndex()
 
             for pattern_id, uncertainty in self._local_demand_pattern.items():
-                pattern_idx = paterns_idx[patterns_id.index(pattern_id)]
-                pattern_length, = epanet_api.getPatternLengths(pattern_id)
-                demand_pattern = np.zeros(pattern_length)
-
-                for t in range(pattern_length):
-                    v = epanet_api.getPatternValue(pattern_idx, t+1)
-                    demand_pattern[t] = v
-
-                    v_ = uncertainty.apply(v)
-                    epanet_api.setPatternValue(pattern_idx, t+1, v_)
+                pattern_idx = epanet_api.getpatternindex(pattern_id)
+                demand_pattern = np.array(epanet_api.get_pattern(pattern_idx))
+                self._cache_nodes_demand_pattern[pattern_id] = np.copy(demand_pattern)
 
-                self._cache_nodes_demand_pattern[pattern_id] = demand_pattern
+                demand_pattern = uncertainty.apply_batch(demand_pattern)
+                epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._global_elevation is not None:
             self._global_elevation.set_random_generator(np_rand_gen)
 
-            elevations = epanet_api.getNodeElevations()
+            elevations = np.array([epanet_api.get_node_elevation(node_idx)
+                                   for node_idx in epanet_api.get_all_nodes_idx()])
             self._cache_nodes_elevation = np.copy(elevations)
 
             elevations = self._global_elevation.apply_batch(elevations)
-            epanet_api.setNodeElevations(elevations)
+            for node_idx, node_elev in enumerate(elevations):
+                epanet_api.setnodevalue(node_idx + 1, EpanetConstants.EN_ELEVATION, node_elev)
 
         if self._local_elevation is not None:
             self._local_elevation.set_random_generator(np_rand_gen)
-            self._cache_nodes_elevation = epanet_api.getNodeElevations()
+            self._cache_nodes_elevation = np.array([epanet_api.get_node_elevation(node_idx)
+                                                    for node_idx in epanet_api.get_all_nodes_idx()])
 
             for node_id, uncertainty in self._local_elevation.items():
-                node_idx = epanet_api.getNodeIndex(node_id)
-                elevation = epanet_api.getNodeElevations(node_idx)
+                node_idx = epanet_api.get_node_idx(node_id)
+                elevation = epanet_api.get_node_elevation(node_idx)
 
                 elevation = uncertainty.apply(elevation)
-                epanet_api.setNodeElevations(node_idx, elevation)
+                epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION, elevation)
 
         if self._local_patterns is not None:
             self._local_patterns.set_random_generator(np_rand_gen)
             self._cache_patterns = {}
 
             for pattern_id, uncertainty in self._local_patterns.items():
-                pattern_idx = epanet_api.getPatternIndex(pattern_id)
-                pattern_length = epanet_api.getPatternLengths(pattern_idx)
-                pattern = np.array([epanet_api.getPatternValue(pattern_idx, t+1)
-                                    for t in range(pattern_length)])
-                self._cache_patterns[pattern_idx] = pattern
+                pattern_idx = epanet_api.getpatternindex(pattern_id)
+                pattern = np.array(epanet_api.get_pattern(pattern_idx))
+                self._cache_patterns[pattern_idx] = np.copy(pattern)
 
                 pattern = uncertainty.apply_batch(pattern)
-                epanet_api.setPattern(pattern_idx, pattern)
+                epanet_api.set_pattern(pattern_idx, pattern.tolist())
 
-        if epanet_api.MSXFile is not None:
+        if epanet_api.msx_file is not None:
             if self._global_constants is not None:
                 self._global_constants.set_random_generator(np_rand_gen)
 
-                constants = np.array(epanet_api.getMSXConstantsValue())
+                constants = np.array([epanet_api.MSXgetconstant(const_idx + 1)
+                                      for const_idx in range(epanet_api.MSXgetcount(EpanetConstants.MSX_CONSTANT))])
                 self._cache_msx_patterns = np.copy(constants)
 
                 constants = self._global_constants.apply_batch(constants)
-                epanet_api.setMSXConstantsValue(constants)
+                for const_idx, const_value in enumerate(constants):
+                    epanet_api.MSXsetconstant(const_idx + 1, const_value)
 
             if self._local_constants:
                 self._local_constants.set_random_generator(np_rand_gen)
 
-                self._cache_msx_patterns = np.array(epanet_api.getMSXConstantsValue())
+                self._cache_msx_patterns = np.array([epanet_api.MSXgetconstant(const_idx + 1)
+                                                     for const_idx in range(epanet_api.MSXgetcount(EpanetConstants.MSX_CONSTANT))])
 
                 for constant_id, uncertainty in self._local_constants.items():
-                    idx = epanet_api.MSXgetindex(ToolkitConstants.MSX_CONSTANT, constant_id)
-                    constant = epanet_api.msx.MSXgetconstant(idx)
+                    idx = epanet_api.MSXgetindex(EpanetConstants.MSX_CONSTANT, constant_id)
+                    constant = epanet_api.MSXgetconstant(idx)
 
                     constant = uncertainty.apply(constant)
-                    epanet_api.msx.MSXsetconstant(idx, constant)
+                    epanet_api.MSXsetconstant(idx, constant)
 
             if self._global_parameters is not None:
                 self._global_parameters.set_random_generator(np_rand_gen)
 
                 self._cache_msx_links_parameters = {}
-                parameters_pipes = epanet_api.getMSXParametersPipesValue()
-                for i, pipe_idx in enumerate(epanet_api.getLinkPipeIndex()):
+                num_params = epanet_api.MSXgetcount(EpanetConstants.MSX_PARAMETER)
+                parameters_pipes = [np.array([epanet_api.MSXgetparameter(EpanetConstants.MSX_LINK,
+                                                                         pipe_idx,
+                                                                         param_idx + 1)
+                                              for param_idx in range(num_params)])
+                                     for pipe_idx in epanet_api.get_all_pipes_idx()]
+                for i, pipe_idx in enumerate(epanet_api.get_all_pipes_idx()):
                     if len(parameters_pipes[i]) == 0:
                         continue
 
-                    self._cache_msx_links_parameters[pipe_idx] = np.array(parameters_pipes[i])
-                    parameters_pipes_val = self._global_parameters.apply_batch(
-                        np.array(parameters_pipes[i]))
-                    epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes_val)
+                    self._cache_msx_links_parameters[pipe_idx] = parameters_pipes[i]
+                    parameters_pipes_val = self._global_parameters.apply_batch(parameters_pipes[i])
+                    for param_idx, param_value in enumerate(parameters_pipes_val):
+                        epanet_api.MSXsetparameter(EpanetConstants.MSX_LINK, pipe_idx,
+                                                   param_idx + 1, param_value)
 
                 self._cache_msx_tanks_parameters = {}
-                parameters_tanks = epanet_api.getMSXParametersTanksValue()
-                for i, tank_idx in enumerate(epanet_api.getNodeTankIndex()):
+                num_params = epanet_api.MSXgetcount(EpanetConstants.MSX_PARAMETER)
+                parameters_tanks = [np.array([epanet_api.MSXgetparameter(EpanetConstants.MSX_NODE,
+                                                                         tank_idx + 1, param_idx + 1)
+                                              for param_idx in range(num_params)])
+                                     for tank_idx in range(epanet_api.get_num_tanks())]
+                for i, tank_idx in enumerate(epanet_api.get_all_tanks_idx()):
                     if parameters_tanks[i] is None or len(parameters_tanks[i]) == 0:
                         continue
 
-                    self._cache_msx_tanks_parameters[tank_idx] = np.array(parameters_tanks[i])
-                    parameters_tanks_val = self._global_parameters.apply_batch(
-                        np.array(parameters_tanks[i]))
-                    epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks_val)
+                    self._cache_msx_tanks_parameters[tank_idx] = parameters_tanks[i]
+                    parameters_tanks_val = self._global_parameters.apply_batch(parameters_tanks[i])
+                    for idx, val in enumerate(parameters_tanks_val):
+                        epanet_api.MSXsetparameter(EpanetConstants.MSX_NODE, tank_idx, idx + 1, val)
 
             if self._local_parameters is not None:
                 self._local_parameters.set_random_generator(np_rand_gen)
@@ -915,36 +939,36 @@ class ModelUncertainty(JsonSerializable):
                 self._cache_msx_tanks_parameters = {}
 
                 for (param_id, item_type, item_id), uncertainty in self._local_parameters.items():
-                    idx, = epanet_api.getMSXParametersIndex([param_id])
+                    idx, = epanet_api.MSXgetindex(EpanetConstants.MSX_PARAMETER, param_id)
 
-                    if item_type == ToolkitConstants.MSX_NODE:
-                        item_idx = epanet_api.getNodeIndex(item_id)
-                    elif item_type == ToolkitConstants.MSX_LINK:
-                        item_idx = epanet_api.getLinkIndex(item_id)
+                    if item_type == EpanetConstants.MSX_NODE:
+                        item_idx = epanet_api.get_node_idx(item_id)
+                    elif item_type == EpanetConstants.MSX_LINK:
+                        item_idx = epanet_api.get_link_idx(item_id)
                     else:
                         raise ValueError(f"Unknown item type '{item_type}' must be either " +
-                                         "ToolkitConstants.MSX_NODE or ToolkitConstants.MSX_LINK")
+                                         "EpanetConstants.MSX_NODE or EpanetConstants.MSX_LINK")
 
-                    parameter = epanet_api.msx.MSXgetparameter(item_type, item_idx, idx)
-                    if item_type == ToolkitConstants.MSX_NODE:
+                    parameter = epanet_api.MSXgetparameter(item_type, item_idx, idx)
+                    if item_type == EpanetConstants.MSX_NODE:
                         self._cache_msx_tanks_parameters[item_idx] = parameter
-                    elif item_type == ToolkitConstants.MSX_LINK:
+                    elif item_type == EpanetConstants.MSX_LINK:
                         self._cache_msx_links_parameters[item_idx] = parameter
 
                     parameter = uncertainty.apply(parameter)
-                    epanet_api.msx.MSXsetparameter(item_type, item_idx, idx, parameter)
+                    epanet_api.MSXsetparameter(item_type, item_idx, idx, parameter)
 
             if self._local_msx_patterns is not None:
                 self._local_msx_patterns.set_random_generator(np_rand_gen)
                 self._cache_msx_patterns = {}
 
                 for pattern_id, uncertainty in self._local_msx_patterns.items():
-                    pattern_idx, = epanet_api.getMSXPatternsIndex([pattern_id])
-                    pattern = epanet_api.getMSXConstantsValue([pattern_idx])
+                    pattern_idx = epanet_api.MSXgetindex(EpanetConstants.MSX_PATTERN, pattern_id)
+                    pattern = np.array(epanet_api.get_msx_pattern(pattern_idx))
                     self._cache_msx_patterns[pattern_idx] = np.copy(pattern)
 
                     pattern = uncertainty.apply_batch(pattern)
-                    epanet_api.setMSXPattern(pattern_idx, pattern)
+                    epanet_api.MSXsetpattern(pattern_idx, pattern.tolist(), len(pattern))
         else:
             if self._local_msx_patterns is not None or self._local_parameters is not None or \
                     self._local_constants is not None or self._global_constants is not None or \

epyt_flow/utils.py

@@ -6,6 +6,7 @@ import math
 import tempfile
 import zipfile
 from pathlib import Path
+import re
 import requests
 from tqdm import tqdm
 import numpy as np
@@ -344,6 +345,71 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
     return ax
 
 
+def download_from_gdrive_if_necessary(download_path: str, url: str, verbose: bool = True) -> None:
+    """
+    Downloads a file from a google drive repository if it does not already exist
+    in a given path.
+
+    Note that if the path (folder) does not already exist, it will be created.
+
+    Parameters
+    ----------
+    download_path : `str`
+        Local path to the file -- if this path does not exist, the file will be downloaded from
+        the provided 'url' and stored in 'download_dir'.
+    url : `str`
+        Web-URL of the google drive repository.
+    verbose : `bool`, optional
+        If True, a progress bar is shown while downloading the file.
+
+        The default is True.
+    """
+    folder_path = str(Path(download_path).parent.absolute())
+    create_path_if_not_exist(folder_path)
+
+    if not os.path.isfile(download_path):
+        session = requests.Session()
+
+        response = session.get(url)
+        html = response.text
+
+        def extract(pattern):
+            match = re.search(pattern, html)
+            return match.group(1) if match else None
+
+        file_id = extract(r'name="id" value="([^"]+)"')
+        file_confirm = extract(r'name="confirm" value="([^"]+)"')
+        file_uuid = extract(r'name="uuid" value="([^"]+)"')
+
+        if not all([file_id, file_confirm, file_uuid]):
+            raise SystemError("Failed to extract download parameters")
+
+        download_url = (
+            f"https://drive.usercontent.google.com/download"
+            f"?id={file_id}&export=download&confirm={file_confirm}&uuid={file_uuid}"
+        )
+
+        response = session.get(download_url, stream=True)
+
+        if response.status_code != 200:
+            raise SystemError(f"Failed to download -- {response.status_code}")
+
+        if verbose is True:
+            content_length = int(response.headers.get('content-length', 0))
+            with open(download_path, "wb") as file, tqdm(desc=download_path,
+                                                         total=content_length,
+                                                         ascii=True,
+                                                         unit='B',
+                                                         unit_scale=True,
+                                                         unit_divisor=1024) as progress_bar:
+                for data in response.iter_content(chunk_size=1024):
+                    size = file.write(data)
+                    progress_bar.update(size)
+        else:
+            with open(download_path, "wb") as f_out:
+                f_out.write(response.content)
+
+
 def download_if_necessary(download_path: str, url: str, verbose: bool = True,
                           backup_urls: list[str] = []) -> None:
     """

epyt_flow/visualization/visualization_utils.py

@@ -188,7 +188,8 @@ class JunctionObject:
 
         valid_params = {
             key: value for key, value in attributes.items()
-            if key in sig.parameters and value is not None
+            if key in sig.parameters and key not in ['vmin', 'vmax', 'cmap']
+            and value is not None
         }
 
         return valid_params
@@ -518,7 +519,8 @@ class EdgeObject:
 
         valid_params = {
             key: value for key, value in attributes.items()
-            if key in sig.parameters and value is not None
+            if key in sig.parameters and key not in ['vmin', 'vmax', 'cmap']
+            and value is not None
         }
 
         return valid_params

{epyt_flow-0.14.1.dist-info → epyt_flow-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epyt-flow
-Version: 0.14.1
+Version: 0.15.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-Expression: MIT
@@ -17,10 +17,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: epyt>=1.2.2
+Requires-Dist: epanet-plus>=0.1.2
 Requires-Dist: requests>=2.31.0
 Requires-Dist: scipy>=1.11.4
 Requires-Dist: u-msgpack-python>=2.8.0
@@ -49,11 +50,13 @@ Dynamic: license-file
 
 <img src="https://github.com/WaterFutures/EPyT-Flow/blob/main/docs/_static/net1_plot.png?raw=true" align="right" height="230px"/>
 
-EPyT-Flow is a Python package building on top of [EPyT](https://github.com/OpenWaterAnalytics/EPyT) 
+EPyT-Flow is a Python package building on top of [EPANET-PLUS](https://github.com/WaterFutures/EPANET-PLUS) --
+an extension and interface of [EPANET](https://github.com/OpenWaterAnalytics/EPANET)
+and [EPANET-MSX](https://github.com/OpenWaterAnalytics/epanet-msx) -- 
 for providing easy access to water distribution network simulations.
 It aims to provide a high-level interface for the easy generation of hydraulic and water quality scenario data.
-However, it also provides access to low-level functions by [EPANET](https://github.com/USEPA/EPANET2.2) 
-and [EPANET-MSX](https://github.com/USEPA/EPANETMSX/).
+However, it also provides access to all functions of EPANET
+and EPANET-MSX.
 
 EPyT-Flow provides easy access to popular benchmark data sets for event detection and localization.
 Furthermore, it also provides an environment for developing and testing control algorithms.
@@ -77,21 +80,13 @@ Unique features of EPyT-Flow that make it superior to other (Python) toolboxes a
 
 ## Installation
 
-EPyT-Flow supports Python 3.9 - 3.13
+EPyT-Flow supports Python 3.9 - 3.14
 
-Note that [EPANET and EPANET-MSX sources](epyt_flow/EPANET/) are compiled and overwrite the binaries
-shipped by EPyT **IF** EPyT-Flow is installed on a Unix system and the *gcc* compiler is available.
-By this, we not only aim to achieve a better performance of the simulations but also avoid any
-compatibility issues of pre-compiled binaries.
-
-#### Prerequisites for macOS users
-The "true" *gcc* compiler (version 15) is needed which is not the
-*clang* compiler that is shipped with Xcode and is linked to gcc!
-
-The correct version of the "true" *gcc* can be installed via [brew](https://brew.sh/):
-```
-brew install gcc@15
-```
+Note that EPyT-Flow builds upon [EPANET-PLUS](https://github.com/WaterFutures/EPANET-PLUS) which
+constitutes a C extension and Python package.
+In the rare case that the pre-build package of EPANET-PLUS does not work on your system,
+you have to build and install it manually -- please follow the instructions provided
+[here](https://epanet-plus.readthedocs.io/en/stable/installation.html).
 
 ### PyPI