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

epyt_flow/VERSION

@@ -1 +1 @@
-0.3.0
+0.5.0

epyt_flow/data/benchmarks/leakdb.py

@@ -543,7 +543,7 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
 
     my_uncertainties = {"pipe_length_uncertainty": MyUniformUncertainty(low=0, high=0.25),
                         "pipe_roughness_uncertainty": MyUniformUncertainty(low=0, high=0.25),
-                        "demand_base_uncertainty": MyUniformUncertainty(low=0, high=0.25)}
+                        "base_demand_uncertainty": MyUniformUncertainty(low=0, high=0.25)}
     model_uncertainty = ModelUncertainty(**my_uncertainties)
 
     # Create sensor config (place pressure and flow sensors everywhere)

epyt_flow/simulation/events/leakages.py

@@ -182,7 +182,7 @@ class Leakage(SystemEvent, JsonSerializable):
             raise TypeError(f"Can not compare 'Leakage' instance with '{type(other)}' instance")
 
         return super().__eq__(other) and self.__link_id == other.link_id \
-            and self.__diameter == other.diameter and self.__profile == other.profile \
+            and self.__diameter == other.diameter and np.all(self.__profile == other.profile) \
             and self.__node_id == other.node_id and self.area == other.area
 
     def __str__(self) -> str:

epyt_flow/simulation/parallel_simulation.py

@@ -1,7 +1,7 @@
 """
 Module provides functions for simulating several scenarios in parallel.
 """
-from typing import Callable
+from typing import Callable, Any
 import os
 import warnings
 from multiprocess import Pool, cpu_count
@@ -38,9 +38,9 @@ def callback_save_to_file(folder_out: str = "") -> Callable[[ScadaData, Scenario
 
 
 def _run_scenario_simulation(scenario_config: ScenarioConfig, scenario_idx: int,
-                             callback: Callable[[ScadaData, ScenarioConfig, int], None]) -> None:
+                             callback: Callable[[ScadaData, ScenarioConfig, int], Any]) -> Any:
     with ScenarioSimulator(scenario_config=scenario_config) as sim:
-        callback(sim.run_simulation(), scenario_config, scenario_idx)
+        return callback(sim.run_simulation(), scenario_config, scenario_idx)
 
 
 class ParallelScenarioSimulation():
@@ -50,8 +50,8 @@ class ParallelScenarioSimulation():
     @staticmethod
     def run(scenarios: list[ScenarioConfig], n_jobs: int = -1,
             max_working_memory_consumption: int = None,
-            callback: Callable[[ScadaData, ScenarioConfig, int], None] = callback_save_to_file()
-            ) -> None:
+            callback: Callable[[ScadaData, ScenarioConfig, int], Any] = callback_save_to_file()
+            ) -> Any:
         """
         Simulates multiple scenarios in parallel.
 
@@ -76,7 +76,7 @@ class ParallelScenarioSimulation():
 
             The callback gets the simulation results as a
             :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` instance, the scenario
-            configuration as a :class: `epyt_flow.simulation.scenario_config.ScenarioConfig`
+            configuration as a :class:`~epyt_flow.simulation.scenario_config.ScenarioConfig`
             instance, and the index of the scenario in 'scenarios' as arguments.
 
             The default is :func:`~epyt_flow.simulation.parallel_simulation.callback_save_to_file`.
@@ -144,4 +144,4 @@ class ParallelScenarioSimulation():
             scenarios_task.append((scenario, scenario_idx, callback))
 
         with Pool(processes=n_parallel_scenarios, maxtasksperchild=1) as pool:
-            pool.starmap(_run_scenario_simulation, scenarios_task)
+            return pool.starmap(_run_scenario_simulation, scenarios_task)

epyt_flow/simulation/scada/scada_data.py

@@ -1163,6 +1163,9 @@ class ScadaData(Serializable):
             :func:`~epyt_flow.simulation.scada.scada_data.ScadaData.get_data` --
             calling this function is the only way of accessing the energy usage of each pump.
 
+            The odering in the returned NumPy array corresponds to the ordering
+            of the pumps in EPANET.
+
         Returns
         -------
         `numpy.ndarray`
@@ -1180,6 +1183,9 @@ class ScadaData(Serializable):
             :func:`~epyt_flow.simulation.scada.scada_data.ScadaData.get_data` --
             calling this function is the only way of accessing the pumps' efficiency.
 
+            The odering in the returned NumPy array corresponds to the ordering
+            of the pumps in EPANET.
+
         Returns
         -------
         `numpy.ndarray`

epyt_flow/simulation/scada/scada_data_export.py

@@ -109,7 +109,7 @@ class ScadaDataExport():
 
         def __get_sensor_unit(sensor_type):
             if sensor_type == "pressure":
-                if is_flowunit_simetric(scada_data.sensor_config.flow_unit):
+                if not is_flowunit_simetric(scada_data.sensor_config.flow_unit):
                     return "psi"
                 else:
                     return "meter"

epyt_flow/simulation/scenario_config.py

@@ -4,6 +4,7 @@ Module provides a class for specifying scenario configurations.
 from typing import Any
 from copy import deepcopy
 import json
+import numpy as np
 
 from ..uncertainty import AbsoluteGaussianUncertainty, RelativeGaussianUncertainty, \
     AbsoluteUniformUncertainty, RelativeUniformUncertainty, ModelUncertainty, \
@@ -350,10 +351,11 @@ class ScenarioConfig(Serializable):
         return self.__f_inp_in == other.f_inp_in and self.__f_msx_in == other.f_msx_in \
             and self.__general_params == other.general_params \
             and self.__memory_consumption_estimate == other.memory_consumption_estimate \
-            and self.__sensor_config == other.sensor_config and self.__controls == other.controls \
+            and self.__sensor_config == other.sensor_config \
+            and np.all(self.__controls == other.controls) \
             and self.__model_uncertainty == other.model_uncertainty \
-            and self.__system_events == other.system_events \
-            and self.__sensor_reading_events == other.sensor_reading_events
+            and np.all(self.__system_events == other.system_events) \
+            and np.all(self.__sensor_reading_events == other.sensor_reading_events)
 
     def __str__(self) -> str:
         return f"f_inp_in: {self.f_inp_in} f_msx_in: {self.f_msx_in} " + \

epyt_flow/simulation/scenario_simulator.py

@@ -298,6 +298,7 @@ class ScenarioSimulator():
 
         return deepcopy(list(filter(lambda e: isinstance(e, Leakage), self.__system_events)))
 
+    @property
     def actuator_events(self) -> list[ActuatorEvent]:
         """
         Gets all actuator events.
@@ -483,6 +484,7 @@ class ScenarioSimulator():
 
         if inp_file_path is not None:
             self.epanet_api.saveInputFile(inp_file_path)
+            self.__f_inp_in = inp_file_path
 
             if export_sensor_config is True:
                 report_desc = "\n\n[REPORT]\n"
@@ -537,6 +539,7 @@ class ScenarioSimulator():
 
         if self.__f_msx_in is not None and msx_file_path is not None:
             self.epanet_api.saveMSXFile(msx_file_path)
+            self.__f_msx_in = msx_file_path
 
             if export_sensor_config is True:
                 report_desc = "\n\n[REPORT]\n"
@@ -708,8 +711,9 @@ class ScenarioSimulator():
 
         general_params = {"hydraulic_time_step": self.get_hydraulic_time_step(),
                           "quality_time_step": self.get_quality_time_step(),
+                          "reporting_time_step": self.epanet_api.getTimeReportingStep(),
                           "simulation_duration": self.get_simulation_duration(),
-                          "flow_units": self.get_flow_units(),
+                          "flow_units_id": self.get_flow_units(),
                           "quality_model": self.get_quality_model(),
                           "demand_model": self.get_demand_model()}
 
@@ -766,6 +770,7 @@ class ScenarioSimulator():
         node_tank_names = self.epanet_api.getNodeTankNameID()
 
         links_id = self.epanet_api.getLinkNameID()
+        links_type = self.epanet_api.getLinkType()
         links_data = self.epanet_api.getNodesConnectingLinksID()
         links_diameter = self.epanet_api.getLinkDiameter()
         links_length = self.epanet_api.getLinkLength()
@@ -774,6 +779,11 @@ class ScenarioSimulator():
         links_wall_coeff = self.epanet_api.getLinkWallReactionCoeff()
         links_loss_coeff = self.epanet_api.getLinkMinorLossCoeff()
 
+        pumps_id = self.epanet_api.getLinkPumpNameID()
+        pumps_type = self.epanet_api.getLinkPumpType()
+
+        valves_id = self.epanet_api.getLinkValveNameID()
+
         # Build graph describing the topology
         nodes = []
         for node_id, node_elevation, node_type, node_coord in zip(nodes_id, nodes_elevation,
@@ -788,16 +798,30 @@ class ScenarioSimulator():
             nodes.append((node_id, node_info))
 
         links = []
-        for link_id, link, diameter, length, roughness_coeff, bulk_coeff, wall_coeff, loss_coeff \
-                in zip(links_id, links_data, links_diameter, links_length, links_roughness_coeff,
-                       links_bulk_coeff, links_wall_coeff, links_loss_coeff):
-            links.append((link_id, link, {"diameter": diameter, "length": length,
-                                          "roughness_coeff": roughness_coeff,
-                                          "bulk_coeff": bulk_coeff, "wall_coeff": wall_coeff,
-                                          "loss_coeff": loss_coeff}))
-
-        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links,
-                               units=self.get_units_category())
+        for link_id, link_type, link, diameter, length, roughness_coeff, bulk_coeff, wall_coeff, loss_coeff \
+                in zip(links_id, links_type, links_data, links_diameter, links_length,
+                       links_roughness_coeff, links_bulk_coeff, links_wall_coeff, links_loss_coeff):
+            links.append((link_id, list(link),
+                          {"type": link_type, "diameter": diameter, "length": length,
+                           "roughness_coeff": roughness_coeff,
+                           "bulk_coeff": bulk_coeff, "wall_coeff": wall_coeff,
+                           "loss_coeff": loss_coeff}))
+
+        pumps = {}
+        for pump_id, pump_type in zip(pumps_id, pumps_type):
+            link_idx = links_id.index(pump_id)
+            link = links_data[link_idx]
+            pumps[pump_id] = {"type": pump_type, "end_points": link}
+
+        valves = {}
+        for valve_id in valves_id:
+            link_idx = links_id.index(valve_id)
+            link = links_data[link_idx]
+            valve_type = links_type[link_idx]
+            valves[valve_id] = {"type": valve_type, "end_points": link}
+
+        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links, pumps=pumps,
+                               valves=valves, units=self.get_units_category())
 
     def randomize_demands(self) -> None:
         """
@@ -1818,14 +1842,14 @@ class ScenarioSimulator():
 
         Parameters
         ----------
-        model_uncertainty : :class:`~epyt_flow.uncertainties.model_uncertainty.ModelUncertainty`
+        model_uncertainty : :class:`~epyt_flow.uncertainty.model_uncertainty.ModelUncertainty`
             Model uncertainty specifications.
         """
         self.__adapt_to_network_changes()
 
         if not isinstance(model_uncertainty, ModelUncertainty):
             raise TypeError("'model_uncertainty' must be an instance of " +
-                            "'epyt_flow.uncertainties.ModelUncertainty' but not of " +
+                            "'epyt_flow.uncertainty.ModelUncertainty' but not of " +
                             f"'{type(model_uncertainty)}'")
 
         self.__model_uncertainty = model_uncertainty

epyt_flow/simulation/scenario_visualizer.py

@@ -12,7 +12,7 @@ class ScenarioVisualizer():
 
     Parameters
     ----------
-    scenario : :class:`epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
+    scenario : :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
         Scenario to be visualized.
     """
     def __init__(self, scenario: ScenarioSimulator):

epyt_flow/simulation/sensor_config.py

@@ -1647,6 +1647,42 @@ class SensorConfig(JsonSerializable):
         """
         return deepcopy(self.__sensors_id_to_idx)
 
+    def get_as_dict(self) -> dict:
+        """
+        Gets the sensor configuration as a dictionary.
+
+        Returns
+        -------
+        `dict`
+            Dictionary of set sensors -- the keys are the sensor types.
+        """
+        r = {}
+
+        if self.__pressure_sensors != []:
+            r["pressure"] = self.__pressure_sensors
+        if self.__flow_sensors != []:
+            r["flow"] = self.__flow_sensors
+        if self.__demand_sensors != []:
+            r["demand"] = self.__demand_sensors
+        if self.__tank_volume_sensors != []:
+            r["tank_volume"] = self.__tank_volume_sensors
+        if self.__valve_state_sensors != []:
+            r["valve_state"] = self.__valve_state_sensors
+        if self.__pump_state_sensors != []:
+            r["pump_state"] = self.__pump_state_sensors
+        if self.__quality_node_sensors != []:
+            r["node_quality"] = self.__quality_node_sensors
+        if self.__quality_link_sensors != []:
+            r["link_quality"] = self.__quality_link_sensors
+        if self.__bulk_species_node_sensors != {}:
+            r["node_bulk_species"] = self.__bulk_species_node_sensors
+        if self.__bulk_species_link_sensors != {}:
+            r["link_bulk_species"] = self.__bulk_species_link_sensors
+        if self.__surface_species_sensors != {}:
+            r["surface_species"] = self.__surface_species_sensors
+
+        return r
+
     def get_attributes(self) -> dict:
         attr = {"nodes": self.__nodes, "links": self.__links,
                 "valves": self.__valves, "pumps": self.__pumps,
@@ -1719,7 +1755,7 @@ class SensorConfig(JsonSerializable):
             f"pump_id_to_idx: {self.__pump_id_to_idx} tank_id_to_idx: {self.__tank_id_to_idx} " +\
             f"valve_id_to_idx: {self.__valve_id_to_idx} " +\
             f"bulkspecies_id_to_idx: {self.__bulkspecies_id_to_idx} " +\
-            f"surfacespecies_id_to_idx: {self.__surfacespecies_id_to_idx}" +\
+            f"surfacespecies_id_to_idx: {self.__surfacespecies_id_to_idx} " +\
             f"pressure_sensors: {self.__pressure_sensors} flow_sensors: {self.__flow_sensors} " +\
             f"demand_sensors: {self.__demand_sensors} " +\
             f"quality_node_sensors: {self.__quality_node_sensors} " +\

epyt_flow/topology.py

@@ -7,6 +7,8 @@ from typing import Any
 import numpy as np
 import networkx as nx
 from scipy.sparse import bsr_array
+from geopandas import GeoDataFrame
+from shapely.geometry import Point, LineString
 
 from .serialization import serializable, JsonSerializable, NETWORK_TOPOLOGY_ID
 
@@ -55,9 +57,15 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         Path to .inp file to which this topology belongs.
     nodes : `list[tuple[str, dict]]`
         List of all nodes -- i.e. node ID and node information such as type and elevation.
-    links : `list[tuple[tuple[str, str], dict]]`
+    links : `list[tuple[str, tuple[str, str], dict]]`
         List of all links/pipes -- i.e. link ID, ID of connecting nodes, and link information
         such as pipe diameter, length, etc.
+    pumps : `dict`
+        List of all pumps -- i.e. valve ID, and information such as
+        pump type and connecting nodes.
+    valves : `dict`
+        List of all valves -- i.e. valve ID, and information such as
+        valve type and connecting nodes.
     units : `int`
         Measurement units category -- i.e. US Customary or SI Metric.
 
@@ -68,12 +76,16 @@ class NetworkTopology(nx.Graph, JsonSerializable):
     """
     def __init__(self, f_inp: str, nodes: list[tuple[str, dict]],
                  links: list[tuple[str, tuple[str, str], dict]],
+                 pumps: dict,
+                 valves: dict,
                  units: int = None,
                  **kwds):
         super().__init__(name=f_inp, **kwds)
 
         self.__nodes = nodes
         self.__links = links
+        self.__pumps = pumps
+        self.__valves = valves
         self.__units = units
 
         if units is None:
@@ -87,15 +99,16 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             self.add_node(node_id, info={"elevation": node_elevation, "type": node_type})
 
         for link_id, link, link_info in links:
+            link_type = link_info["type"]
             link_diameter = link_info["diameter"]
             link_length = link_info["length"]
             self.add_edge(link[0], link[1], length=link_length,
-                          info={"id": link_id, "nodes": link, "diameter": link_diameter,
-                                "length": link_length})
+                          info={"id": link_id, "type": link_type, "nodes": link,
+                                "diameter": link_diameter, "length": link_length})
 
     def convert_units(self, units: int) -> Any:
         """
-        Converts this instance to a :class:`epyt_flow.topology.NetworkTopology` instance
+        Converts this instance to a :class:`~epyt_flow.topology.NetworkTopology` instance
         where everything is measured in given measurement units category
         (US Customary or SI Metric).
 
@@ -111,7 +124,7 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         Returns
         -------
-        :class:`epyt_flow.topology.NetworkTopology`
+        :class:`~epyt_flow.topology.NetworkTopology`
             Network topology with the new measurements units.
         """
         if self.__units is None:
@@ -161,7 +174,8 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
             links.append((link_id, link_nodes, link_info))
 
-        return NetworkTopology(f_inp=self.name, nodes=nodes, links=links, units=units)
+        return NetworkTopology(f_inp=self.name, nodes=nodes, links=links, pumps=self.pumps,
+                               valves=self.valves, units=units)
 
     def get_all_nodes(self) -> list[str]:
         """
@@ -185,6 +199,98 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         """
         return [(link_id, end_points) for link_id, end_points, _ in self.__links]
 
+    def get_all_junctions(self) -> list[str]:
+        """
+        Gets all junctions -- i.e. nodes that are not tanks or reservoirs.
+
+        Returns
+        -------
+        `list[str]`
+            List of all junctions.
+        """
+        r = []
+
+        for node_id in self.get_all_nodes():
+            if self.get_node_info(node_id)["type"] == "JUNCTION":
+                r.append(node_id)
+
+        return r
+
+    def get_all_tanks(self) -> list[str]:
+        """
+        Gets all tanks -- i.e. nodes that are not junctions or reservoirs.
+
+        Returns
+        -------
+        `list[str]`
+            List of all tanks.
+        """
+        r = []
+
+        for node_id in self.get_all_nodes():
+            if self.get_node_info(node_id)["type"] == "TANK":
+                r.append(node_id)
+
+        return r
+
+    def get_all_reservoirs(self) -> list[str]:
+        """
+        Gets all reservoirs -- i.e. nodes that are not junctions or tanks.
+
+        Returns
+        -------
+        `list[str]`
+            List of all reservoirs.
+        """
+        r = []
+
+        for node_id in self.get_all_nodes():
+            if self.get_node_info(node_id)["type"] == "RESERVOIR":
+                r.append(node_id)
+
+        return r
+
+    def get_all_pipes(self) -> list[tuple[str, tuple[str, str]]]:
+        """
+        Gets all pipes -- i.e. links that not valves or pumps.
+
+        Returns
+        -------
+        `list[tuple[str, tuple[str, str]]]`
+            List of all pipes -- (link ID, (left node ID, right node ID)).
+        """
+        r = []
+
+        for link_id, link_nodes in self.get_all_links():
+            link_info = self.get_link_info(link_id)
+
+            if link_info["type"] == "PIPE":
+                r.append((link_id, link_nodes))
+
+        return r
+
+    def get_all_pumps(self) -> list[str]:
+        """
+        Gets the IDs of all pumps.
+
+        Returns
+        -------
+        `list[str]`
+            Pump IDs.
+        """
+        return self.__pumps.keys()
+
+    def get_all_valves(self) -> list[str]:
+        """
+        Gets the IDs of all valves.
+
+        Returns
+        -------
+        `list[str]`
+            Valve IDs.
+        """
+        return self.__valves.keys()
+
     def get_node_info(self, node_id: str) -> dict:
         """
         Gets all information (e.g. elevation, type, etc.) associated with a given node.
@@ -207,17 +313,19 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
     def get_link_info(self, link_id: str) -> dict:
         """
-        Gets all information (e.g. diameter, length, etc.) associated with a given link/pipe.
+        Gets all information (e.g. diameter, length, etc.) associated with a given link.
+
+        Note that links can be pipes, pumps, or valves.
 
         Parameters
         ----------
         link_id : `str`
-            ID of the link/pipe.
+            ID of the link.
 
         Returns
         -------
         `dict`
-            Information associated with the given link/pipe.
+            Information associated with the given link.
         """
         for link_id_, link_nodes, link_info in self.__links:
             if link_id_ == link_id:
@@ -225,6 +333,68 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         raise ValueError(f"Unknown link '{link_id}'")
 
+    def get_pump_info(self, pump_id: str) -> dict:
+        """
+        Gets all information associated with a given pump.
+
+        Parameters
+        ----------
+        pump_id : `str`
+            ID of the pump.
+
+        Returns
+        -------
+        `dict`
+            Pump information.
+        """
+        if pump_id in self.__pumps:
+            return self.__pumps[pump_id]
+        else:
+            raise ValueError(f"Unknown pump: '{pump_id}'")
+
+    def get_valve_info(self, valve_id: str) -> dict:
+        """
+        Gets all information associated with a given valve.
+
+        Parameters
+        ----------
+        valve_id : `str`
+            ID of the valve.
+
+        Returns
+        -------
+        `dict`
+            Valve information.
+        """
+        if valve_id in self.__valves:
+            return self.__valves[valve_id]
+        else:
+            raise ValueError(f"Unknown valve: '{valve_id}'")
+
+    @property
+    def pumps(self) -> dict:
+        """
+        Gets all pumps -- i.e. ID and associated information such as the pump type.
+
+        Returns
+        -------
+        `dict`
+            All pumps and their associated information.
+        """
+        return deepcopy(self.__pumps)
+
+    @property
+    def valves(self) -> dict:
+        """
+        Gets all valves -- i.e. ID and associated information such as the valve type.
+
+        Returns
+        -------
+        `dict`
+            All valves and their associated information.
+        """
+        return deepcopy(self.__valves)
+
     @property
     def units(self) -> int:
         """
@@ -251,18 +421,120 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             self.get_all_nodes() == other.get_all_nodes() \
             and all(link_a[0] == link_b[0] and all(link_a[1] == link_b[1])
                     for link_a, link_b in zip(self.get_all_links(), other.get_all_links())) \
-            and self.__units == other.units
+            and self.__units == other.units \
+            and self.__pumps == other.pumps \
+            and self.__valves == other.valves
 
     def __str__(self) -> str:
         return f"f_inp: {self.name} nodes: {self.__nodes} links: {self.__links} " +\
+            f"pumps: {self.__pumps} valves: {self.__valves} " +\
             f"units: {unitscategoryid_to_str(self.__units)}"
 
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"f_inp": self.name,
                                            "nodes": self.__nodes,
                                            "links": self.__links,
+                                           "pumps": self.__pumps,
+                                           "valves": self.__valves,
                                            "units": self.__units}
 
+    def to_gis(self, coord_reference_system: str = None, pumps_as_points: bool = False,
+               valves_as_points: bool = False) -> dict:
+        """
+        Gets the network topology as a dictionary of `geopandas.GeoDataFrames` instances --
+        i.e. each quantity (nodes, links/pipes, valves, etc.) is represented by a
+        `geopandas.GeoDataFrames` instance.
+
+        Parameters
+        ----------
+        coord_reference_system : `str`, optional
+            Coordinate reference system.
+
+            The default is None.
+        pumps_as_points : `bool`, optional
+            If True, pumps are represented by points, otherwise by lines.
+
+            The default is False.
+
+        valves_as_points : `bool`, optional
+            If True, valves are represented by points, otherwise by lines.
+
+            The default is False.
+
+        Returns
+        -------
+        `dict`
+            Network topology as a dictionary of `geopandas.GeoDataFrames` instances.
+            If a quantity does not exist, the data frame will be None.
+        """
+        gis = {"nodes": None, "links": None,
+               "tanks": None, "reservoirs": None,
+               "valves": None, "pumps": None}
+
+        # Nodes
+        node_data = {"id": [], "type": [], "elevation": [], "geometry": []}
+        tank_data = {"id": [], "elevation": [], "diameter": [], "geometry": []}
+        reservoir_data = {"id": [], "elevation": [], "geometry": []}
+        for node_id in self.get_all_nodes():
+            node_info = self.get_node_info(node_id)
+
+            node_data["id"].append(node_id)
+            node_data["type"].append(node_info["type"])
+            node_data["elevation"].append(node_info["elevation"])
+            node_data["geometry"].append(Point(node_info["coord"]))
+
+            if node_info["type"] == "TANK":
+                tank_data["id"].append(node_id)
+                tank_data["elevation"].append(node_info["elevation"])
+                tank_data["diameter"].append(node_info["diameter"])
+                tank_data["geometry"].append(Point(node_info["coord"]))
+            elif node_info["type"] == "RESERVOIR":
+                reservoir_data["id"].append(node_id)
+                reservoir_data["elevation"].append(node_info["elevation"])
+                reservoir_data["geometry"].append(Point(node_info["coord"]))
+
+        gis["nodes"] = GeoDataFrame(node_data, crs=coord_reference_system)
+        gis["tanks"] = GeoDataFrame(tank_data, crs=coord_reference_system)
+        gis["reservoirs"] = GeoDataFrame(reservoir_data, crs=coord_reference_system)
+
+        # Links
+        pipe_data = {"id": [], "type": [], "end_point_a": [], "end_point_b": [],
+                     "length": [], "diameter": [], "geometry": []}
+        valve_data = {"id": [], "type": [], "geometry": []}
+        pump_data = {"id": [], "type": [], "geometry": []}
+        for link_id, link_nodes in self.get_all_links():
+            link_info = self.get_link_info(link_id)
+            end_points_coord = [self.get_node_info(n)["coord"] for n in link_nodes]
+
+            if link_info["type"] == "PIPE":
+                pipe_data["id"].append(link_id)
+                pipe_data["type"].append(link_info["type"])
+                pipe_data["end_point_a"].append(link_nodes[0])
+                pipe_data["end_point_b"].append(link_nodes[1])
+                pipe_data["length"].append(link_info["length"])
+                pipe_data["diameter"].append(link_info["diameter"])
+                pipe_data["geometry"].append(LineString(end_points_coord))
+            elif link_info["type"] == "PUMP":
+                pump_data["id"].append(link_id)
+                pump_data["type"].append(self.get_pump_info(link_id)["type"])
+                if pumps_as_points is True:
+                    pump_data["geometry"].append(Point(end_points_coord[0]))
+                else:
+                    pump_data["geometry"].append(LineString(end_points_coord))
+            else:   # Valve
+                valve_data["id"].append(link_id)
+                valve_data["type"].append(self.get_valve_info[link_id]["type"])
+                if valves_as_points is True:
+                    valve_data["geometry"].append(Point(end_points_coord[0]))
+                else:
+                    valve_data["geometry"].append(LineString(end_points_coord))
+
+        gis["pipes"] = GeoDataFrame(pipe_data, crs=coord_reference_system)
+        gis["valves"] = GeoDataFrame(valve_data, crs=coord_reference_system)
+        gis["pumps"] = GeoDataFrame(pump_data, crs=coord_reference_system)
+
+        return gis
+
     def get_adj_matrix(self) -> bsr_array:
         """
         Gets the adjacency matrix of this graph.

epyt_flow/uncertainty/model_uncertainty.py

@@ -2,6 +2,7 @@
 Module provides a class for implementing model uncertainty.
 """
 from copy import deepcopy
+import warnings
 import epyt
 import numpy as np
 
@@ -29,7 +30,7 @@ class ModelUncertainty(JsonSerializable):
         Uncertainty of pipe diameters. None, in the case of no uncertainty.
 
         The default is None.
-    demand_base_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+    base_demand_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
         Uncertainty of base demands. None, in the case of no uncertainty.
 
         The default is None.
@@ -53,11 +54,17 @@ class ModelUncertainty(JsonSerializable):
     def __init__(self, pipe_length_uncertainty: Uncertainty = None,
                  pipe_roughness_uncertainty: Uncertainty = None,
                  pipe_diameter_uncertainty: Uncertainty = None,
-                 demand_base_uncertainty: Uncertainty = None,
+                 base_demand_uncertainty: Uncertainty = None,
                  demand_pattern_uncertainty: Uncertainty = None,
                  elevation_uncertainty: Uncertainty = None,
                  constants_uncertainty: Uncertainty = None,
-                 parameters_uncertainty: Uncertainty = None, **kwds):
+                 parameters_uncertainty: Uncertainty = None,
+                 demand_base_uncertainty: Uncertainty = None, **kwds):
+        if demand_base_uncertainty is not None:
+            warnings.warn("Loading a file that was created with an outdated version of EPyT-Flow" +
+                          " -- support of such old files will be removed in the next release!",
+                          DeprecationWarning)
+
         if pipe_length_uncertainty is not None:
             if not isinstance(pipe_length_uncertainty, Uncertainty):
                 raise TypeError("'pipe_length_uncertainty' must be an instance of " +
@@ -73,11 +80,11 @@ class ModelUncertainty(JsonSerializable):
                 raise TypeError("'pipe_diameter_uncertainty' must be an instance of " +
                                 "'epyt_flow.uncertainty.Uncertainty' but not of " +
                                 f"'{type(pipe_diameter_uncertainty)}'")
-        if demand_base_uncertainty is not None:
-            if not isinstance(demand_base_uncertainty, Uncertainty):
-                raise TypeError("'demand_base_uncertainty' must be an instance of " +
+        if base_demand_uncertainty is not None:
+            if not isinstance(base_demand_uncertainty, Uncertainty):
+                raise TypeError("'base_demand_uncertainty' must be an instance of " +
                                 "'epyt_flow.uncertainty.Uncertainty' but not of " +
-                                f"'{type(demand_base_uncertainty)}'")
+                                f"'{type(base_demand_uncertainty)}'")
         if demand_pattern_uncertainty is not None:
             if not isinstance(demand_pattern_uncertainty, Uncertainty):
                 raise TypeError("'demand_pattern_uncertainty' must be an instance of " +
@@ -102,7 +109,7 @@ class ModelUncertainty(JsonSerializable):
         self.__pipe_length = pipe_length_uncertainty
         self.__pipe_roughness = pipe_roughness_uncertainty
         self.__pipe_diameter = pipe_diameter_uncertainty
-        self.__demand_base = demand_base_uncertainty
+        self.__base_demand = base_demand_uncertainty
         self.__demand_pattern = demand_pattern_uncertainty
         self.__elevation = elevation_uncertainty
         self.__constants = constants_uncertainty
@@ -147,16 +154,16 @@ class ModelUncertainty(JsonSerializable):
         return deepcopy(self.__pipe_diameter)
 
     @property
-    def demand_base(self) -> Uncertainty:
+    def base_demand(self) -> Uncertainty:
         """
-        Gets the demand base uncertainty.
+        Gets the base demand uncertainty.
 
         Returns
         -------
         :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
             Demand base uncertainty.
         """
-        return deepcopy(self.__demand_base)
+        return deepcopy(self.__base_demand)
 
     @property
     def demand_pattern(self) -> Uncertainty:
@@ -210,7 +217,7 @@ class ModelUncertainty(JsonSerializable):
         return super().get_attributes() | {"pipe_length_uncertainty": self.__pipe_length,
                                            "pipe_roughness_uncertainty": self.__pipe_roughness,
                                            "pipe_diameter_uncertainty": self.__pipe_diameter,
-                                           "demand_base_uncertainty": self.__demand_base,
+                                           "base_demand_uncertainty": self.__base_demand,
                                            "demand_pattern_uncertainty": self.__demand_pattern,
                                            "elevation_uncertainty": self.__elevation,
                                            "constants_uncertainty": self.__constants,
@@ -224,14 +231,14 @@ class ModelUncertainty(JsonSerializable):
         return self.__pipe_length == other.pipe_length \
             and self.__pipe_roughness == other.pipe_roughness \
             and self.__pipe_diameter == other.pipe_diameter \
-            and self.__demand_base == other.demand_base \
+            and self.__base_demand == other.base_demand \
             and self.__demand_pattern == other.demand_pattern \
             and self.__elevation == other.elevation \
             and self.__parameters == other.parameters and self.__constants == other.constants
 
     def __str__(self) -> str:
         return f"pipe_length: {self.__pipe_length} pipe_roughness: {self.__pipe_roughness} " + \
-            f"pipe_diameter: {self.__pipe_diameter} demand_base: {self.__demand_base} " + \
+            f"pipe_diameter: {self.__pipe_diameter} demand_base: {self.__base_demand} " + \
             f"demand_pattern: {self.__demand_pattern} elevation: {self.__elevation} " + \
             f"constants: {self.__constants} parameters: {self.__parameters}"
 
@@ -259,14 +266,14 @@ class ModelUncertainty(JsonSerializable):
             coeffs = self.__pipe_roughness.apply_batch(coeffs)
             epanet_api.setLinkRoughnessCoeff(coeffs)
 
-        if self.__demand_base is not None:
+        if self.__base_demand is not None:
             all_nodes_idx = epanet_api.getNodeIndex()
             for node_idx in all_nodes_idx:
                 n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
-                for demand_category in range(1, n_demand_categories):
-                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category]
-                    base_demand = self.__demand_base.apply(base_demand)
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category, base_demand)
+                for demand_category in range(n_demand_categories):
+                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category + 1]
+                    base_demand = self.__base_demand.apply(base_demand)
+                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
 
         if self.__demand_pattern is not None:
             demand_patterns_idx = epanet_api.getNodeDemandPatternIndex()

epyt_flow/utils.py

@@ -153,8 +153,10 @@ def plot_timeseries_data(data: np.ndarray, labels: list[str] = None, x_axis_labe
 
 
 def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
-                               confidence_interval: np.ndarray = None, show: bool = True,
-                               ax: matplotlib.axes.Axes = None) -> matplotlib.axes.Axes:
+                               confidence_interval: np.ndarray = None,
+                               x_axis_label: str = None, y_axis_label: str = None,
+                               show: bool = True, ax: matplotlib.axes.Axes = None
+                               ) -> matplotlib.axes.Axes:
     """
     Plots the prediction (e.g. forecast) of *single* time series together with the
     ground truth time series. In addition, confidence intervals can be plotted as well.
@@ -169,6 +171,14 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
         Confidence interval (upper and lower value) for each prediction in `y_pred`.
         If not None, the confidence interval is plotted as well.
 
+        The default is None.
+    x_axis_label : `str`, optional
+        X axis label.
+
+        The default is None.
+    y_axis_label : `str`, optional
+        Y axis label.
+
         The default is None.
     show : `bool`, optional
         If True, the plot/figure is shown in a window.
@@ -198,6 +208,14 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
         raise ValueError("'y_pred' must be a 1d array")
     if len(y.shape) != 1:
         raise ValueError("'y' must be a 1d array")
+    if x_axis_label is not None:
+        if not isinstance(x_axis_label, str):
+            raise TypeError("'x_axis_label' must be an instance of 'str' " +
+                            f"but not of '{type(x_axis_label)}'")
+    if y_axis_label is not None:
+        if not isinstance(y_axis_label, str):
+            raise TypeError("'y_axis_label' must be an instance of 'str' " +
+                            f"but not of '{type(y_axis_label)}'")
     if not isinstance(show, bool):
         raise TypeError(f"'show' must be an instance of 'bool' but not of '{type(show)}'")
     if ax is not None:
@@ -214,10 +232,15 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
                         y_pred - confidence_interval[0],
                         y_pred + confidence_interval[1],
                         alpha=0.5)
-    ax.plot(y_pred, ".-", label="Prediction")
     ax.plot(y, ".-", label="Ground truth")
+    ax.plot(y_pred, ".-", label="Prediction")
     ax.legend()
 
+    if x_axis_label is not None:
+        ax.set_xlabel(x_axis_label)
+    if y_axis_label is not None:
+        ax.set_ylabel(y_axis_label)
+
     if show is True and fig is not None:
         plt.show()
 

{epyt_flow-0.3.0.dist-info → epyt_flow-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: epyt-flow
-Version: 0.3.0
+Version: 0.5.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
@@ -30,6 +30,7 @@ Requires-Dist: tqdm >=4.66.2
 Requires-Dist: openpyxl >=3.1.2
 Requires-Dist: falcon >=3.1.3
 Requires-Dist: multiprocess >=0.70.16
+Requires-Dist: geopandas >=0.14.4
 Requires-Dist: psutil
 
 [![pypi](https://img.shields.io/pypi/v/epyt-flow.svg)](https://pypi.org/project/epyt-flow/)

{epyt_flow-0.3.0.dist-info → epyt_flow-0.5.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-epyt_flow/VERSION,sha256=2RXMldbKj0euKXcT7UbU5cXZnd0p_Dxh4mO98wXytbA,6
+epyt_flow/VERSION,sha256=oK1QZAE5pST4ZZEVcUW_HUZ06pwGW_6iFVjw97BEMMg,6
 epyt_flow/__init__.py,sha256=KNDiPWiHdB9a5ZF1ipjA1uoq61TwU2ThjaStpvSLBtY,1742
 epyt_flow/metrics.py,sha256=kvt42pzZrUR9PSlCyK4uq5kj6UlYHkt7OcCjLnI1RQE,12883
 epyt_flow/serialization.py,sha256=nBcwc3aMUbHF0zW8Nvpc49kKeLPh75blc3gzjKDR1ok,12893
-epyt_flow/topology.py,sha256=LTWqKwXVRfg3zYN16x5_ZH-wUj8U5hB2spLWzlEnsqM,14221
-epyt_flow/utils.py,sha256=-1DFDpST_J86AB6pd2ufe_QQ06_tvQqB-5wD8DXacaU,11507
+epyt_flow/topology.py,sha256=yKIspoX4uoo9rAeVR5eWJ6D91QNozHzvzjiry9bFkNI,23424
+epyt_flow/utils.py,sha256=AB2MuknQ_16UE-URQe1WShIS7dmSyFwZYVHxMVT539k,12379
 epyt_flow/EPANET/compile_linux.sh,sha256=wcrDyiB8NkivmaC-X9FI2WxhY3IJqDLiyIbVTv2XEPY,489
 epyt_flow/EPANET/compile_macos.sh,sha256=1K33-bPdgr01EIf87YUvmOFHXyOkBWI6mKXQ8x1Hzmo,504
 epyt_flow/EPANET/EPANET/SRC_engines/AUTHORS,sha256=yie5yAsEEPY0984PmkSRUdqEU9rVvRSGGWmjxdwCYMU,925
@@ -87,7 +87,7 @@ epyt_flow/data/benchmarks/batadal_data.py,sha256=oIzcysGivMPAgrfzrk5l8i-j6Ii96DP
 epyt_flow/data/benchmarks/battledim.py,sha256=K0j9tbfxuXJmqBQY_e5XBJZGDYavaOZ7efkCT96Fb8A,20167
 epyt_flow/data/benchmarks/battledim_data.py,sha256=0vHm-2eAiLv6U-n5dqUUWS1o_szFRy9mVJ3eqDRp4PE,3373
 epyt_flow/data/benchmarks/gecco_water_quality.py,sha256=1buZRJiNf4jsqWYg4Ud90GhqaiLVo4yij3RAZJkzsqE,10985
-epyt_flow/data/benchmarks/leakdb.py,sha256=jMMSxJ6XrjOo5b91sGwplT5mTcv3k9Xr-TnWz3BhMbw,24952
+epyt_flow/data/benchmarks/leakdb.py,sha256=Z_ah6FXAyN4M7dn4jH0qYFmKTtViNHd6Jn2L9I6nMYg,24952
 epyt_flow/data/benchmarks/leakdb_data.py,sha256=FNssgMkC1wqWVlaOrrihr4Od9trEZY7KeK5KuBeRMvM,507058
 epyt_flow/data/benchmarks/water_usage.py,sha256=FLqjff3pha33oEU9ZM3UGPXn9eJJumsJH8Gdj7YFX3A,4778
 epyt_flow/gym/__init__.py,sha256=KNTDtPTEtHwZ4ehHfj9qGw81Z9acFqPIgMzYUzH5_uM,115
@@ -110,30 +110,30 @@ epyt_flow/rest_api/scenario/handlers.py,sha256=bDqMa-jM4hOMVqs0XvQJtHbQDZx9FP40G
 epyt_flow/rest_api/scenario/simulation_handlers.py,sha256=oY1Ch6ZQgYT_5WeE1I7tvGqpDKlT664GHLdmcVKP7ek,5905
 epyt_flow/rest_api/scenario/uncertainty_handlers.py,sha256=uuu6AP11ZZUp2P3Dnukjg5ZTjyYKljlubg1xLN1GnXY,4048
 epyt_flow/simulation/__init__.py,sha256=VGGJqJRUoXZjKJ0-m6KPp3JQqD_1TFW0pofLgkwZJ8M,164
-epyt_flow/simulation/parallel_simulation.py,sha256=mMevycgtnMjV2FDq50WS4HjAdcOlI72Aj6FBX4HZDtc,6508
-epyt_flow/simulation/scenario_config.py,sha256=6xZD3Gwje-isiSaoKCXLkX0R81SVDH8LojsXdDlH8to,26540
-epyt_flow/simulation/scenario_simulator.py,sha256=Yf2oo3fMfvxrrW3nX8d6y2plrNcGZ-DBK-5mpLtplms,92070
-epyt_flow/simulation/scenario_visualizer.py,sha256=2gr1o731VLlhA8wQKgrLT94M43FsBNKjG_eucZPHy9A,2186
-epyt_flow/simulation/sensor_config.py,sha256=9pUzvRm4HSF8zZ-Hu4pdpxzTjpNSdNmDvcPhRaRFNAI,80175
+epyt_flow/simulation/parallel_simulation.py,sha256=VmC7xemjxRB_N0fx1AAQ7ux82tnyTi7jk7jfFpeg7gM,6523
+epyt_flow/simulation/scenario_config.py,sha256=_Zs0EPyfet0mTLpAt-oMN3k7jCW3x7_VbOQHpHVntrA,26597
+epyt_flow/simulation/scenario_simulator.py,sha256=1amMxO-PVHBU_AN6K9Ga6xzFmpaX2ZZnhwkirtj6IgY,93036
+epyt_flow/simulation/scenario_visualizer.py,sha256=fpj67zl69q-byg7Oxocqhmu1S3P7B3ROCkSYzWyM--0,2187
+epyt_flow/simulation/sensor_config.py,sha256=MGeerEnLhyFLE6XA2p-X9Swd4k0o0T7QboeGuTUFq7I,81584
 epyt_flow/simulation/events/__init__.py,sha256=tIdqzs7_Cus4X2kbZG4Jl2zs-zsk_4rnajFOCvL0zlI,185
 epyt_flow/simulation/events/actuator_events.py,sha256=2_MPYbYO9As6fMkm5Oy9pjSB9kCvFuKpGu8ykYDAydg,7903
 epyt_flow/simulation/events/event.py,sha256=kARPV20XCAl6zxnJwI9U7ICtZUPACO_rgAmtHm1mGCs,2603
-epyt_flow/simulation/events/leakages.py,sha256=lDZNKOtVtQsKYhAuJ5Mt7tG6IfHX1436eSkjYTkQiZk,15267
+epyt_flow/simulation/events/leakages.py,sha256=g4asHeB3s7mJekY7WTdmTFb6NsoHov8lEciclS3um0I,15275
 epyt_flow/simulation/events/sensor_faults.py,sha256=XX6k-GJh9RWZ4x54eGj9um-Ir9Eq41tY_9pRSCeYeqc,8447
 epyt_flow/simulation/events/sensor_reading_attack.py,sha256=bo5VavArN0wD5AHbIXJC9NFGZ7KR1uyWE6tBtwj0k9I,7538
 epyt_flow/simulation/events/sensor_reading_event.py,sha256=rQ-CmdpSUyZzDFYwNUGH2jGoj0oyU-aAb-7E8Oshhqw,6785
 epyt_flow/simulation/events/system_event.py,sha256=0KI2iaAaOyC9Y-FIfFVazeKT_4ORQRp26gWyMBUu_3c,2396
 epyt_flow/simulation/scada/__init__.py,sha256=ZFAxJVqwEVsgiyFilFetnb13gPhZg1JEOPWYvKIJT4c,90
 epyt_flow/simulation/scada/advanced_control.py,sha256=Enox02ggt36HdFLX7ZNxgxuqsTEeu9AACHrzU8CXGrg,4489
-epyt_flow/simulation/scada/scada_data.py,sha256=NfGDGrQ7HIXTcShUaGeCALTvGmM5LAJW0Bgmk0H4UQg,104867
-epyt_flow/simulation/scada/scada_data_export.py,sha256=YlA-6R6XpQ28POyKsw1eEe23gMAuDFvwBuDUN-ciu2Y,11213
+epyt_flow/simulation/scada/scada_data.py,sha256=WaFSppBHvJOwSyLYNs9Pu2GngSzWsfkpqPfBQoeiEcU,105101
+epyt_flow/simulation/scada/scada_data_export.py,sha256=0BwDgV-5qZx17wIyWQ8Nl2TPgho3mBI49027RDq8sDA,11217
 epyt_flow/uncertainty/__init__.py,sha256=ZRjuJL9rDpWVSdPwObPxFpEmMTcgAl3VmPOsS6cIyGg,89
-epyt_flow/uncertainty/model_uncertainty.py,sha256=DAgyfvdTQvOVMyduuPIpPB_8e3GIMNpehu6kh0jFg0s,13592
+epyt_flow/uncertainty/model_uncertainty.py,sha256=-2QT2AffZerKZyZ_w_mmeqYpfBALyPDvV61sCrvcK1o,13966
 epyt_flow/uncertainty/sensor_noise.py,sha256=zJVULxnxVPSSqc6UW0iwZ9O-HGf9dn4CwScPqf4yCY0,2324
 epyt_flow/uncertainty/uncertainties.py,sha256=X-o7GZUC0HELtzpoXIAJaAeYOw35N05TuRoSmStcCpI,17669
 epyt_flow/uncertainty/utils.py,sha256=gq66c9-QMOxOqI6wgWLyFxjVV0fbG0_8Yzd6mQjNYNo,5315
-epyt_flow-0.3.0.dist-info/LICENSE,sha256=-4hYIY2BLmCkdOv2_PehEwlnMKTCes8_oyIUXjKtkug,1076
-epyt_flow-0.3.0.dist-info/METADATA,sha256=tnq12BhftSSxemSI93ONtLRs4K4eT8R_I71NENxUuX4,7053
-epyt_flow-0.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-epyt_flow-0.3.0.dist-info/top_level.txt,sha256=Wh_kd7TRL8ownCw3Y3dxx-9C0iTSk6wNauv_NX9JcrY,10
-epyt_flow-0.3.0.dist-info/RECORD,,
+epyt_flow-0.5.0.dist-info/LICENSE,sha256=-4hYIY2BLmCkdOv2_PehEwlnMKTCes8_oyIUXjKtkug,1076
+epyt_flow-0.5.0.dist-info/METADATA,sha256=a7kEbUctgxuMBJ06GNrwJnAlr_arMtcxHg-TZzSiD8M,7087
+epyt_flow-0.5.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+epyt_flow-0.5.0.dist-info/top_level.txt,sha256=Wh_kd7TRL8ownCw3Y3dxx-9C0iTSk6wNauv_NX9JcrY,10
+epyt_flow-0.5.0.dist-info/RECORD,,

{epyt_flow-0.3.0.dist-info → epyt_flow-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any