Skip to content

network_plots

This module contains classes for managing network plots.

NetworkPlot

Bases: ABC

Interface for plotting a network.

Source code in shift\network_plots.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
class NetworkPlot(ABC):
    """Interface for plotting a network."""

    @abstractmethod
    def show(self) -> None:
        """Abstract method for showing the plot."""
        pass

    @abstractmethod
    def html_export(self, html_file_path: str):
        """Abstract method for exporting network plot in html format.

        Args:
           html_file_path (str): Valid html file path
        """
        pass

html_export(html_file_path) abstractmethod

Abstract method for exporting network plot in html format.

Parameters:

Name Type Description Default
html_file_path str

Valid html file path

 required
Source code in shift\network_plots.py 
59
60
61
62
63
64
65
66
@abstractmethod
def html_export(self, html_file_path: str):
    """Abstract method for exporting network plot in html format.

    Args:
       html_file_path (str): Valid html file path
    """
    pass

show() abstractmethod

Abstract method for showing the plot.

Source code in shift\network_plots.py 
54
55
56
57
@abstractmethod
def show(self) -> None:
    """Abstract method for showing the plot."""
    pass

PlotlyGISNetworkPlot

Bases: NetworkPlot

" Class for plotting network along with GIS layer using plotly.

Attributes:

Name Type Description
network nx.Graph

Graph to plot
access_token str

MapBox token
style str

Valid MapBox style
zoom_level int

Initial Zoom level for the plot
asset_specific_style Union[None, dict]

Asset specific style dict
data dict

Plot data managed internally
fig go.Figure

go.Figure instance managed internally
Source code in shift\network_plots.py 
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
class PlotlyGISNetworkPlot(NetworkPlot):
    """ " Class for plotting network along with GIS layer using plotly.

    Attributes:
        network (nx.Graph): Graph to plot
        access_token (str): MapBox token
        style (str): Valid MapBox style
        zoom_level (int): Initial Zoom level for the plot
        asset_specific_style (Union[None, dict]): Asset specific style dict
        data (dict): Plot data managed internally
        fig (go.Figure): go.Figure instance managed internally
    """

    def __init__(
        self,
        network: nx.Graph,
        access_token: str,
        style: str = "satellite",
        zoom_level: int = 13,
        asset_specific_style: Union[None, dict] = None,
    ) -> None:
        """Constructor for `PlotlyGISNetworkPlot` class.

        Args:
            network (nx.Graph): Graph to plot
            access_token (str): MapBox token
            style (str): Valid MapBox style
            zoom_level (int): Initial Zoom level for the plot
            asset_specific_style (Union[None, dict]): Asset specific style dict

        Raises:
            InvalidMapboxStyle: If invalid mapbox style is passed
            ZoomLevelNotInRangeError: If invalid zoom level is passed
            EmptyAssetStyleDict: If `asset_specific_style` is empty
        """

        self.access_token = access_token
        self.network = network
        self.style = style
        if self.style not in MAP_STYLES:
            raise InvalidMapboxStyle(self.style)

        self.zoom_level = zoom_level
        if self.zoom_level < MIN_ZOOM_LEVEL or self.zoom_level > MAX_ZOOM_LEVEL:
            raise ZoomLevelNotInRangeError(self.zoom_level)

        self.asset_specific_style = (
            asset_specific_style if asset_specific_style is not None else {}
        )
        if not self.asset_specific_style:
            raise EmptyAssetStyleDict()

        self.data = []
        self._add_data()
        self._prepare_plot()

    def _add_data(self):
        """Private method to add data for generating plot."""

        scatter_data = {}
        for node in self.network.nodes.data():

            if "type" not in node[1]:
                raise MissingKeyDataForNetworkNode("type")

            if "data" not in node[1]:
                node[1]["data"] = {}

            if node[1]["type"] not in scatter_data:
                scatter_data[node[1]["type"]] = {
                    "longitudes": [],
                    "latitudes": [],
                    "texts": [],
                }

            scatter_data[node[1]["type"]]["latitudes"].append(node[1]["pos"][1])
            scatter_data[node[1]["type"]]["longitudes"].append(
                node[1]["pos"][0]
            )
            text = "<br>".join([f"{k}:{v}" for k, v in node[1]["data"].items()])
            scatter_data[node[1]["type"]]["texts"].append(text)

        for key, style_dict in self.asset_specific_style.get(
            "nodes", {}
        ).items():

            if key in scatter_data:
                self.add_scatter_data(
                    scatter_data[key]["longitudes"],
                    scatter_data[key]["latitudes"],
                    scatter_data[key]["texts"],
                    color=style_dict.get("color", "blue"),
                    size=style_dict.get("size", 5),
                )
            else:
                raise InvalidNodeType(key)

        line_data = {}
        node_data = {node[0]: node[1] for node in self.network.nodes.data()}
        for edge in self.network.edges():

            edge_data = self.network.get_edge_data(*edge)
            if "type" not in edge_data:
                raise MissingKeyDataForNetworkNode("type")

            if edge_data["type"] not in line_data:
                line_data[edge_data["type"]] = {
                    "longitudes": [],
                    "latitudes": [],
                }

            line_data[edge_data["type"]]["latitudes"].extend(
                [
                    node_data[edge[0]]["pos"][1],
                    node_data[edge[1]]["pos"][1],
                    None,
                ]
            )
            line_data[edge_data["type"]]["longitudes"].extend(
                [
                    node_data[edge[0]]["pos"][0],
                    node_data[edge[1]]["pos"][0],
                    None,
                ]
            )

        for key, style_dict in self.asset_specific_style.get(
            "edges", {}
        ).items():

            if key in line_data:
                self.add_line_data(
                    line_data[key]["latitudes"],
                    line_data[key]["longitudes"],
                    line_color=style_dict.get("color", "red"),
                    size=style_dict.get("size", 10),
                )
            else:
                raise InvalidNodeType(key)

    def add_scatter_data(
        self,
        lons: List[float],
        lats: List[float],
        texts: List[str],
        color: str = "blue",
        size: int = 5,
    ) -> None:
        """Add scatter data to the map.

        Args:
            lons (List[float]): List of longitudes
            lats (List[float]): List of latitudes
            texts (List[str]): List of hover texts
            color (str): Color for scatter plot
            size (int): Size for scatter plot
        """

        self.data.append(
            go.Scattermapbox(
                mode="markers",
                lon=lons,
                lat=lats,
                text=texts,
                marker={"size": size, "color": color},
            )
        )

    def add_line_data(
        self,
        lats: List[float],
        lons: List[float],
        line_color: str = "red",
        size: int = 10,
    ) -> None:
        """Method for adding line data.

        Args:
            lats (List[float]): List of latitudes
            lons (List[float]): List of longitudes
            line_color (str): Color for line plot
            size (int): Size for line plot
        """
        del size
        self.data.append(
            go.Scattermapbox(
                mode="markers+lines",
                lon=lons,
                lat=lats,
                marker={"size": 2},
                line={"color": line_color},
            )
        )

    def _get_map_centre(self) -> dict:
        """Private method to get map center."""

        longitudes = [node[1]["pos"][0] for node in self.network.nodes.data()]
        latitudes = [node[1]["pos"][1] for node in self.network.nodes.data()]
        return {
            "lon": sum(longitudes) / len(longitudes),
            "lat": sum(latitudes) / len(latitudes),
        }

    def _prepare_plot(self) -> None:
        """Private method to prepare the plot"""

        self.fig = go.Figure(data=self.data)
        self.fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0})
        self.fig.update_mapboxes(
            {
                "accesstoken": self.access_token,
                "style": self.style,
                "center": self._get_map_centre(),
                "zoom": self.zoom_level,
            }
        )

    def show(self) -> None:
        """Refer to base class for more details."""
        self.fig.show()

    def html_export(self, html_file_path: str) -> None:
        """Refer to base class for more details."""
        if not os.path.exists(os.path.dirname(html_file_path)):
            raise FolderNotFoundError(os.path.dirname(html_file_path))
        self.fig.write_html(html_file_path)

__init__(network, access_token, style='satellite', zoom_level=13, asset_specific_style=None)

Constructor for PlotlyGISNetworkPlot class.

Parameters:

Name Type Description Default
network nx.Graph

Graph to plot

 required
access_token str

MapBox token

 required
style str

Valid MapBox style

 'satellite'
zoom_level int

Initial Zoom level for the plot

 13
asset_specific_style Union[None, dict]

Asset specific style dict

 None

Raises:

Type Description
InvalidMapboxStyle

If invalid mapbox style is passed
ZoomLevelNotInRangeError

If invalid zoom level is passed
EmptyAssetStyleDict

If asset_specific_style is empty
Source code in shift\network_plots.py 
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
def __init__(
    self,
    network: nx.Graph,
    access_token: str,
    style: str = "satellite",
    zoom_level: int = 13,
    asset_specific_style: Union[None, dict] = None,
) -> None:
    """Constructor for `PlotlyGISNetworkPlot` class.

    Args:
        network (nx.Graph): Graph to plot
        access_token (str): MapBox token
        style (str): Valid MapBox style
        zoom_level (int): Initial Zoom level for the plot
        asset_specific_style (Union[None, dict]): Asset specific style dict

    Raises:
        InvalidMapboxStyle: If invalid mapbox style is passed
        ZoomLevelNotInRangeError: If invalid zoom level is passed
        EmptyAssetStyleDict: If `asset_specific_style` is empty
    """

    self.access_token = access_token
    self.network = network
    self.style = style
    if self.style not in MAP_STYLES:
        raise InvalidMapboxStyle(self.style)

    self.zoom_level = zoom_level
    if self.zoom_level < MIN_ZOOM_LEVEL or self.zoom_level > MAX_ZOOM_LEVEL:
        raise ZoomLevelNotInRangeError(self.zoom_level)

    self.asset_specific_style = (
        asset_specific_style if asset_specific_style is not None else {}
    )
    if not self.asset_specific_style:
        raise EmptyAssetStyleDict()

    self.data = []
    self._add_data()
    self._prepare_plot()

add_line_data(lats, lons, line_color='red', size=10)

Method for adding line data.

Parameters:

Name Type Description Default
lats List[float]

List of latitudes

 required
lons List[float]

List of longitudes

 required
line_color str

Color for line plot

 'red'
size int

Size for line plot

 10
Source code in shift\network_plots.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
def add_line_data(
    self,
    lats: List[float],
    lons: List[float],
    line_color: str = "red",
    size: int = 10,
) -> None:
    """Method for adding line data.

    Args:
        lats (List[float]): List of latitudes
        lons (List[float]): List of longitudes
        line_color (str): Color for line plot
        size (int): Size for line plot
    """
    del size
    self.data.append(
        go.Scattermapbox(
            mode="markers+lines",
            lon=lons,
            lat=lats,
            marker={"size": 2},
            line={"color": line_color},
        )
    )

add_scatter_data(lons, lats, texts, color='blue', size=5)

Add scatter data to the map.

Parameters:

Name Type Description Default
lons List[float]

List of longitudes

 required
lats List[float]

List of latitudes

 required
texts List[str]

List of hover texts

 required
color str

Color for scatter plot

 'blue'
size int

Size for scatter plot

 5
Source code in shift\network_plots.py 
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
def add_scatter_data(
    self,
    lons: List[float],
    lats: List[float],
    texts: List[str],
    color: str = "blue",
    size: int = 5,
) -> None:
    """Add scatter data to the map.

    Args:
        lons (List[float]): List of longitudes
        lats (List[float]): List of latitudes
        texts (List[str]): List of hover texts
        color (str): Color for scatter plot
        size (int): Size for scatter plot
    """

    self.data.append(
        go.Scattermapbox(
            mode="markers",
            lon=lons,
            lat=lats,
            text=texts,
            marker={"size": size, "color": color},
        )
    )

html_export(html_file_path)

Refer to base class for more details.

Source code in shift\network_plots.py 
291
292
293
294
295
def html_export(self, html_file_path: str) -> None:
    """Refer to base class for more details."""
    if not os.path.exists(os.path.dirname(html_file_path)):
        raise FolderNotFoundError(os.path.dirname(html_file_path))
    self.fig.write_html(html_file_path)

show()

Refer to base class for more details.

Source code in shift\network_plots.py 
287
288
289
def show(self) -> None:
    """Refer to base class for more details."""
    self.fig.show()