Fix exception causes and messages all over the codebase (#4015)

9 files changed, 58 insertions, 51 deletions

diff --git a/networkx/readwrite/adjlist.py b/networkx/readwrite/adjlist.py
index 0ea2daa1..911d4bfd 100644
--- a/networkx/readwrite/adjlist.py
+++ b/networkx/readwrite/adjlist.py
@@ -194,14 +194,16 @@ def parse_adjlist(lines, comments='#', delimiter=None,
         if nodetype is not None:
             try:
                 u = nodetype(u)
-            except:
-                raise TypeError(f"Failed to convert node ({u}) to type {nodetype}")
+            except BaseException as e:
+                raise TypeError(f"Failed to convert node ({u}) to type "
+                                f"{nodetype}") from e
         G.add_node(u)
         if nodetype is not None:
             try:
                 vlist = list(map(nodetype, vlist))
-            except:
-                raise TypeError(f"Failed to convert nodes ({','.join(vlist)}) to type {nodetype}")
+            except BaseException as e:
+                raise TypeError(f"Failed to convert nodes ({','.join(vlist)}) "
+                                f"to type {nodetype}") from e
         G.add_edges_from([(u, v) for v in vlist])
     return G
 
diff --git a/networkx/readwrite/edgelist.py b/networkx/readwrite/edgelist.py
index 02a533af..bdb8b7ff 100644
--- a/networkx/readwrite/edgelist.py
+++ b/networkx/readwrite/edgelist.py
@@ -256,8 +256,9 @@ def parse_edgelist(lines, comments='#', delimiter=None,
             try:
                 u = nodetype(u)
                 v = nodetype(v)
-            except:
-                raise TypeError(f"Failed to convert nodes {u},{v} to type {nodetype}.")
+            except BaseException as e:
+                raise TypeError(f"Failed to convert nodes {u},{v} "
+                                f"to type {nodetype}.") from e
 
         if len(d) == 0 or data is False:
             # no data or data type specified
@@ -266,8 +267,9 @@ def parse_edgelist(lines, comments='#', delimiter=None,
             # no edge types specified
             try:  # try to evaluate as dictionary
                 edgedata = dict(literal_eval(' '.join(d)))
-            except:
-                raise TypeError(f"Failed to convert edge data ({d}) to dictionary.")
+            except BaseException as e:
+                raise TypeError(f"Failed to convert edge data ({d}) "
+                                f"to dictionary.") from e
         else:
             # convert edge data to dictionary with specified keys and type
             if len(d) != len(data):
@@ -276,8 +278,9 @@ def parse_edgelist(lines, comments='#', delimiter=None,
             for (edge_key, edge_type), edge_value in zip(data, d):
                 try:
                     edge_value = edge_type(edge_value)
-                except:
-                    raise TypeError(f"Failed to convert {edge_key} data {edge_value} to type {edge_type}.")
+                except BaseException as e:
+                    raise TypeError(f"Failed to convert {edge_key} data {edge_value} "
+                                    f"to type {edge_type}.") from e
                 edgedata.update({edge_key: edge_value})
         G.add_edge(u, v, **edgedata)
     return G
diff --git a/networkx/readwrite/gexf.py b/networkx/readwrite/gexf.py
index 8fb3163a..3f5d5ed1 100644
--- a/networkx/readwrite/gexf.py
+++ b/networkx/readwrite/gexf.py
@@ -950,8 +950,8 @@ class GEXFReader(GEXF):
                 key = a.get("for")  # for is required
                 try:  # should be in our gexf_keys dictionary
                     title = gexf_keys[key]["title"]
-                except KeyError:
-                    raise nx.NetworkXError(f"No attribute defined for={key}.")
+                except KeyError as e:
+                    raise nx.NetworkXError(f"No attribute defined for={key}.") from e
                 atype = gexf_keys[key]["type"]
                 value = a.get("value")
                 if atype == "boolean":
@@ -1021,12 +1021,10 @@ def relabel_gexf_graph(G):
     # build mapping of node labels, do some error checking
     try:
         mapping = [(u, G.nodes[u]["label"]) for u in G]
-    except KeyError:
+    except KeyError as e:
         raise nx.NetworkXError(
-            "Failed to relabel nodes: "
-            "missing node labels found. "
-            "Use relabel=False."
-        )
+            "Failed to relabel nodes: missing node labels found. Use relabel=False."
+        ) from e
     x, y = zip(*mapping)
     if len(set(y)) != len(G):
         raise nx.NetworkXError(
diff --git a/networkx/readwrite/gml.py b/networkx/readwrite/gml.py
index 8f035629..3bebce0f 100644
--- a/networkx/readwrite/gml.py
+++ b/networkx/readwrite/gml.py
@@ -107,8 +107,8 @@ def literal_destringizer(rep):
         orig_rep = rep
         try:
             return literal_eval(rep)
-        except SyntaxError:
-            raise ValueError(f"{orig_rep!r} is not a valid Python literal")
+        except SyntaxError as e:
+            raise ValueError(f"{orig_rep!r} is not a valid Python literal") from e
     else:
         raise ValueError(f"{rep!r} is not a string")
 
@@ -170,8 +170,8 @@ def read_gml(path, label="label", destringizer=None):
         for line in lines:
             try:
                 line = line.decode("ascii")
-            except UnicodeDecodeError:
-                raise NetworkXError("input is not ASCII-encoded")
+            except UnicodeDecodeError as e:
+                raise NetworkXError("input is not ASCII-encoded") from e
             if not isinstance(line, str):
                 lines = str(lines)
             if line and line[-1] == "\n":
@@ -235,8 +235,8 @@ def parse_gml(lines, label="label", destringizer=None):
         if isinstance(line, bytes):
             try:
                 line.decode("ascii")
-            except UnicodeDecodeError:
-                raise NetworkXError("input is not ASCII-encoded")
+            except UnicodeDecodeError as e:
+                raise NetworkXError("input is not ASCII-encoded") from e
         if not isinstance(line, str):
             line = str(line)
         return line
@@ -420,8 +420,8 @@ def parse_gml_lines(lines, label, destringizer):
     def pop_attr(dct, category, attr, i):
         try:
             return dct.pop(attr)
-        except KeyError:
-            raise NetworkXError(f"{category} #{i} has no '{attr}' attribute")
+        except KeyError as e:
+            raise NetworkXError(f"{category} #{i} has no '{attr}' attribute") from e
 
     nodes = graph.get("node", [])
     mapping = {}
@@ -705,10 +705,10 @@ def generate_gml(G, stringizer=None):
                 if stringizer:
                     try:
                         value = stringizer(value)
-                    except ValueError:
+                    except ValueError as e:
                         raise NetworkXError(
                             f"{value!r} cannot be converted into a string"
-                        )
+                        ) from e
                 if not isinstance(value, str):
                     raise NetworkXError(f"{value!r} is not a string")
                 yield indent + key + ' "' + escape(value) + '"'
diff --git a/networkx/readwrite/graphml.py b/networkx/readwrite/graphml.py
index 241cb9d4..edcbfcdb 100644
--- a/networkx/readwrite/graphml.py
+++ b/networkx/readwrite/graphml.py
@@ -807,8 +807,8 @@ class GraphMLReader(GraphML):
             try:
                 data_name = graphml_keys[key]['name']
                 data_type = graphml_keys[key]['type']
-            except KeyError:
-                raise nx.NetworkXError(f"Bad GraphML data: no key {key}")
+            except KeyError as e:
+                raise nx.NetworkXError(f"Bad GraphML data: no key {key}") from e
             text = data_element.text
             # assume anything with subelements is a yfiles extension
             if text is not None and len(list(data_element)) == 0:
diff --git a/networkx/readwrite/leda.py b/networkx/readwrite/leda.py
index 90aef9f4..9a261c82 100644
--- a/networkx/readwrite/leda.py
+++ b/networkx/readwrite/leda.py
@@ -94,8 +94,8 @@ def parse_leda(lines):
     for i in range(m):
         try:
             s, t, reversal, label = next(lines).split()
-        except:
-            raise NetworkXError(f'Too few fields in LEDA.GRAPH edge {i+1}')
+        except BaseException as e:
+            raise NetworkXError(f'Too few fields in LEDA.GRAPH edge {i+1}') from e
         # BEWARE: no handling of reversal edges
         G.add_edge(node[int(s)], node[int(t)], label=label[2:-2])
     return G
diff --git a/networkx/readwrite/multiline_adjlist.py b/networkx/readwrite/multiline_adjlist.py
index 46f2c804..702ec832 100644
--- a/networkx/readwrite/multiline_adjlist.py
+++ b/networkx/readwrite/multiline_adjlist.py
@@ -228,21 +228,22 @@ def parse_multiline_adjlist(lines, comments='#', delimiter=None,
         try:
             (u, deg) = line.strip().split(delimiter)
             deg = int(deg)
-        except:
-            raise TypeError(f"Failed to read node and degree on line ({line})")
+        except BaseException as e:
+            raise TypeError(f"Failed to read node and degree on line ({line})") from e
         if nodetype is not None:
             try:
                 u = nodetype(u)
-            except:
-                raise TypeError(f"Failed to convert node ({u}) to type {nodetype}")
+            except BaseException as e:
+                raise TypeError(f"Failed to convert node ({u}) to "
+                                f"type {nodetype}") from e
         G.add_node(u)
         for i in range(deg):
             while True:
                 try:
                     line = next(lines)
-                except StopIteration:
+                except StopIteration as e:
                     msg = f"Failed to find neighbor for node ({u})"
-                    raise TypeError(msg)
+                    raise TypeError(msg) from e
                 p = line.find(comments)
                 if p >= 0:
                     line = line[:p]
@@ -257,13 +258,15 @@ def parse_multiline_adjlist(lines, comments='#', delimiter=None,
             if nodetype is not None:
                 try:
                     v = nodetype(v)
-                except:
-                    raise TypeError("Failed to convert node ({v}) to type {nodetype}")
+                except BaseException as e:
+                    raise TypeError(f"Failed to convert node ({v}) "
+                                    f"to type {nodetype}") from e
             if edgetype is not None:
                 try:
                     edgedata = {'weight': edgetype(data)}
-                except:
-                    raise TypeError("Failed to convert edge data ({data}) to type {edgetype}")
+                except BaseException as e:
+                    raise TypeError(f"Failed to convert edge data ({data}) "
+                                    f"to type {edgetype}") from e
             else:
                 try:  # try to evaluate
                     edgedata = literal_eval(data)
diff --git a/networkx/readwrite/nx_shp.py b/networkx/readwrite/nx_shp.py
index 598d632c..15a74c61 100644
--- a/networkx/readwrite/nx_shp.py
+++ b/networkx/readwrite/nx_shp.py
@@ -77,8 +77,8 @@ def read_shp(path, simplify=True, geom_attrs=True, strict=True):
     """
     try:
         from osgeo import ogr
-    except ImportError:
-        raise ImportError("read_shp requires OGR: http://www.gdal.org/")
+    except ImportError as e:
+        raise ImportError("read_shp requires OGR: http://www.gdal.org/") from e
 
     if not isinstance(path, str):
         return
@@ -147,8 +147,9 @@ def edges_from_line(geom, attrs, simplify=True, geom_attrs=True):
     """
     try:
         from osgeo import ogr
-    except ImportError:
-        raise ImportError("edges_from_line requires OGR: http://www.gdal.org/")
+    except ImportError as e:
+        raise ImportError("edges_from_line requires OGR: "
+                          "http://www.gdal.org/") from e
 
     if geom.GetGeometryType() == ogr.wkbLineString:
         if simplify:
@@ -208,8 +209,8 @@ def write_shp(G, outdir):
     """
     try:
         from osgeo import ogr
-    except ImportError:
-        raise ImportError("write_shp requires OGR: http://www.gdal.org/")
+    except ImportError as e:
+        raise ImportError("write_shp requires OGR: http://www.gdal.org/") from e
     # easier to debug in python if ogr throws exceptions
     ogr.UseExceptions()
 
diff --git a/networkx/readwrite/nx_yaml.py b/networkx/readwrite/nx_yaml.py
index 4b8ef405..05dafe96 100644
--- a/networkx/readwrite/nx_yaml.py
+++ b/networkx/readwrite/nx_yaml.py
@@ -50,8 +50,8 @@ def write_yaml(G_to_be_yaml, path_for_yaml_output, **kwds):
     """
     try:
         import yaml
-    except ImportError:
-        raise ImportError("write_yaml() requires PyYAML: http://pyyaml.org/")
+    except ImportError as e:
+        raise ImportError("write_yaml() requires PyYAML: http://pyyaml.org/") from e
     yaml.dump(G_to_be_yaml, path_for_yaml_output, **kwds)
 
 
@@ -85,8 +85,8 @@ def read_yaml(path):
     """
     try:
         import yaml
-    except ImportError:
-        raise ImportError("read_yaml() requires PyYAML: http://pyyaml.org/")
+    except ImportError as e:
+        raise ImportError("read_yaml() requires PyYAML: http://pyyaml.org/") from e
 
     G = yaml.load(path, Loader=yaml.FullLoader)
     return G