Fixed database typo and removed unnecessary class identifier.

venv/share/doc/networkx-2.5/examples/drawing/README.txt

@@ -0,0 +1,2 @@
+Drawing
+-------

venv/share/doc/networkx-2.5/examples/drawing/plot_atlas.py

@@ -0,0 +1,73 @@
+"""
+=====
+Atlas
+=====
+
+Atlas of all graphs of 6 nodes or less.
+"""
+
+import random
+
+# This example needs Graphviz and either PyGraphviz or pydot.
+# from networkx.drawing.nx_pydot import graphviz_layout
+from networkx.drawing.nx_agraph import graphviz_layout
+
+import matplotlib.pyplot as plt
+
+import networkx as nx
+from networkx.algorithms.isomorphism.isomorph import (
+    graph_could_be_isomorphic as isomorphic,
+)
+from networkx.generators.atlas import graph_atlas_g
+
+
+def atlas6():
+    """ Return the atlas of all connected graphs of 6 nodes or less.
+        Attempt to check for isomorphisms and remove.
+    """
+
+    Atlas = graph_atlas_g()[0:208]  # 208
+    # remove isolated nodes, only connected graphs are left
+    U = nx.Graph()  # graph for union of all graphs in atlas
+    for G in Atlas:
+        zerodegree = [n for n in G if G.degree(n) == 0]
+        for n in zerodegree:
+            G.remove_node(n)
+        U = nx.disjoint_union(U, G)
+
+    # iterator of graphs of all connected components
+    C = (U.subgraph(c) for c in nx.connected_components(U))
+
+    UU = nx.Graph()
+    # do quick isomorphic-like check, not a true isomorphism checker
+    nlist = []  # list of nonisomorphic graphs
+    for G in C:
+        # check against all nonisomorphic graphs so far
+        if not iso(G, nlist):
+            nlist.append(G)
+            UU = nx.disjoint_union(UU, G)  # union the nonisomorphic graphs
+    return UU
+
+
+def iso(G1, glist):
+    """Quick and dirty nonisomorphism checker used to check isomorphisms."""
+    for G2 in glist:
+        if isomorphic(G1, G2):
+            return True
+    return False
+
+
+G = atlas6()
+
+print(f"graph has {nx.number_of_nodes(G)} nodes with {nx.number_of_edges(G)} edges")
+print(nx.number_connected_components(G), "connected components")
+
+plt.figure(1, figsize=(8, 8))
+# layout graphs with positions using graphviz neato
+pos = graphviz_layout(G, prog="neato")
+# color nodes the same in each connected subgraph
+C = (G.subgraph(c) for c in nx.connected_components(G))
+for g in C:
+    c = [random.random()] * nx.number_of_nodes(g)  # random color...
+    nx.draw(g, pos, node_size=40, node_color=c, vmin=0.0, vmax=1.0, with_labels=False)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_chess_masters.py

@@ -0,0 +1,147 @@
+"""
+=============
+Chess Masters
+=============
+
+An example of the MultiDiGraph clas
+
+The function chess_pgn_graph reads a collection of chess matches stored in the
+specified PGN file (PGN ="Portable Game Notation").  Here the (compressed)
+default file::
+
+    chess_masters_WCC.pgn.bz2
+
+contains all 685 World Chess Championship matches from 1886--1985.
+(data from http://chessproblem.my-free-games.com/chess/games/Download-PGN.php)
+
+The `chess_pgn_graph()` function returns a `MultiDiGraph` with multiple edges.
+Each node is the last name of a chess master. Each edge is directed from white
+to black and contains selected game info.
+
+The key statement in `chess_pgn_graph` below is::
+
+    G.add_edge(white, black, game_info)
+
+where `game_info` is a `dict` describing each game.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# tag names specifying what game info should be
+# stored in the dict on each digraph edge
+game_details = ["Event", "Date", "Result", "ECO", "Site"]
+
+
+def chess_pgn_graph(pgn_file="chess_masters_WCC.pgn.bz2"):
+    """Read chess games in pgn format in pgn_file.
+
+    Filenames ending in .gz or .bz2 will be uncompressed.
+
+    Return the MultiDiGraph of players connected by a chess game.
+    Edges contain game data in a dict.
+
+    """
+    import bz2
+
+    G = nx.MultiDiGraph()
+    game = {}
+    datafile = bz2.BZ2File(pgn_file)
+    lines = (line.decode().rstrip("\r\n") for line in datafile)
+    for line in lines:
+        if line.startswith("["):
+            tag, value = line[1:-1].split(" ", 1)
+            game[str(tag)] = value.strip('"')
+        else:
+            # empty line after tag set indicates
+            # we finished reading game info
+            if game:
+                white = game.pop("White")
+                black = game.pop("Black")
+                G.add_edge(white, black, **game)
+                game = {}
+    return G
+
+
+G = chess_pgn_graph()
+
+ngames = G.number_of_edges()
+nplayers = G.number_of_nodes()
+
+print(f"Loaded {ngames} chess games between {nplayers} players\n")
+
+# identify connected components
+# of the undirected version
+H = G.to_undirected()
+Gcc = [H.subgraph(c) for c in nx.connected_components(H)]
+if len(Gcc) > 1:
+    print("Note the disconnected component consisting of:")
+    print(Gcc[1].nodes())
+
+# find all games with B97 opening (as described in ECO)
+openings = {game_info["ECO"] for (white, black, game_info) in G.edges(data=True)}
+print(f"\nFrom a total of {len(openings)} different openings,")
+print("the following games used the Sicilian opening")
+print('with the Najdorff 7...Qb6 "Poisoned Pawn" variation.\n')
+
+for (white, black, game_info) in G.edges(data=True):
+    if game_info["ECO"] == "B97":
+        print(white, "vs", black)
+        for k, v in game_info.items():
+            print("   ", k, ": ", v)
+        print("\n")
+
+# make new undirected graph H without multi-edges
+H = nx.Graph(G)
+
+# edge width is proportional number of games played
+edgewidth = []
+for (u, v, d) in H.edges(data=True):
+    edgewidth.append(len(G.get_edge_data(u, v)))
+
+# node size is proportional to number of games won
+wins = dict.fromkeys(G.nodes(), 0.0)
+for (u, v, d) in G.edges(data=True):
+    r = d["Result"].split("-")
+    if r[0] == "1":
+        wins[u] += 1.0
+    elif r[0] == "1/2":
+        wins[u] += 0.5
+        wins[v] += 0.5
+    else:
+        wins[v] += 1.0
+try:
+    pos = nx.nx_agraph.graphviz_layout(H)
+except ImportError:
+    pos = nx.spring_layout(H, iterations=20)
+
+plt.rcParams["text.usetex"] = False
+plt.figure(figsize=(8, 8))
+nx.draw_networkx_edges(H, pos, alpha=0.3, width=edgewidth, edge_color="m")
+nodesize = [wins[v] * 50 for v in H]
+nx.draw_networkx_nodes(H, pos, node_size=nodesize, node_color="w", alpha=0.4)
+nx.draw_networkx_edges(H, pos, alpha=0.4, node_size=0, width=1, edge_color="k")
+nx.draw_networkx_labels(H, pos, font_size=14)
+font = {"fontname": "Helvetica", "color": "k", "fontweight": "bold", "fontsize": 14}
+plt.title("World Chess Championship Games: 1886 - 1985", font)
+
+# change font and write text (using data coordinates)
+font = {"fontname": "Helvetica", "color": "r", "fontweight": "bold", "fontsize": 14}
+
+plt.text(
+    0.5,
+    0.97,
+    "edge width = # games played",
+    horizontalalignment="center",
+    transform=plt.gca().transAxes,
+)
+plt.text(
+    0.5,
+    0.94,
+    "node size = # games won",
+    horizontalalignment="center",
+    transform=plt.gca().transAxes,
+)
+
+plt.axis("off")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_circular_tree.py

@@ -0,0 +1,20 @@
+"""
+=============
+Circular Tree
+=============
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# This example needs Graphviz and either PyGraphviz or pydot
+# from networkx.drawing.nx_pydot import graphviz_layout
+from networkx.drawing.nx_agraph import graphviz_layout
+
+
+G = nx.balanced_tree(3, 5)
+pos = graphviz_layout(G, prog="twopi", args="")
+plt.figure(figsize=(8, 8))
+nx.draw(G, pos, node_size=20, alpha=0.5, node_color="blue", with_labels=False)
+plt.axis("equal")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_degree_histogram.py

@@ -0,0 +1,35 @@
+"""
+================
+Degree histogram
+================
+
+Draw degree histogram with matplotlib.
+Random graph shown as inset
+"""
+import collections
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.gnp_random_graph(100, 0.02)
+
+degree_sequence = sorted([d for n, d in G.degree()], reverse=True)  # degree sequence
+degreeCount = collections.Counter(degree_sequence)
+deg, cnt = zip(*degreeCount.items())
+
+fig, ax = plt.subplots()
+plt.bar(deg, cnt, width=0.80, color="b")
+
+plt.title("Degree Histogram")
+plt.ylabel("Count")
+plt.xlabel("Degree")
+ax.set_xticks([d + 0.4 for d in deg])
+ax.set_xticklabels(deg)
+
+# draw graph in inset
+plt.axes([0.4, 0.4, 0.5, 0.5])
+Gcc = G.subgraph(sorted(nx.connected_components(G), key=len, reverse=True)[0])
+pos = nx.spring_layout(G)
+plt.axis("off")
+nx.draw_networkx_nodes(G, pos, node_size=20)
+nx.draw_networkx_edges(G, pos, alpha=0.4)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_degree_rank.py

@@ -0,0 +1,29 @@
+"""
+===========
+Degree Rank
+===========
+
+Random graph from given degree sequence.
+Draw degree rank plot and graph with matplotlib.
+"""
+import networkx as nx
+import matplotlib.pyplot as plt
+
+G = nx.gnp_random_graph(100, 0.02)
+
+degree_sequence = sorted([d for n, d in G.degree()], reverse=True)
+dmax = max(degree_sequence)
+
+plt.loglog(degree_sequence, "b-", marker="o")
+plt.title("Degree rank plot")
+plt.ylabel("degree")
+plt.xlabel("rank")
+
+# draw graph in inset
+plt.axes([0.45, 0.45, 0.45, 0.45])
+Gcc = G.subgraph(sorted(nx.connected_components(G), key=len, reverse=True)[0])
+pos = nx.spring_layout(Gcc)
+plt.axis("off")
+nx.draw_networkx_nodes(Gcc, pos, node_size=20)
+nx.draw_networkx_edges(Gcc, pos, alpha=0.4)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_directed.py

@@ -0,0 +1,44 @@
+"""
+==============
+Directed Graph
+==============
+
+Draw a graph with directed edges using a colormap and different node sizes.
+
+Edges have different colors and alphas (opacity). Drawn using matplotlib.
+"""
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.generators.directed.random_k_out_graph(10, 3, 0.5)
+pos = nx.layout.spring_layout(G)
+
+node_sizes = [3 + 10 * i for i in range(len(G))]
+M = G.number_of_edges()
+edge_colors = range(2, M + 2)
+edge_alphas = [(5 + i) / (M + 4) for i in range(M)]
+
+nodes = nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color="blue")
+edges = nx.draw_networkx_edges(
+    G,
+    pos,
+    node_size=node_sizes,
+    arrowstyle="->",
+    arrowsize=10,
+    edge_color=edge_colors,
+    edge_cmap=plt.cm.Blues,
+    width=2,
+)
+# set alpha value for each edge
+for i in range(M):
+    edges[i].set_alpha(edge_alphas[i])
+
+pc = mpl.collections.PatchCollection(edges, cmap=plt.cm.Blues)
+pc.set_array(edge_colors)
+plt.colorbar(pc)
+
+ax = plt.gca()
+ax.set_axis_off()
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_edge_colormap.py

@@ -0,0 +1,23 @@
+"""
+=============
+Edge Colormap
+=============
+
+Draw a graph with matplotlib, color edges.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.star_graph(20)
+pos = nx.spring_layout(G)
+colors = range(20)
+options = {
+    "node_color": "#A0CBE2",
+    "edge_color": colors,
+    "width": 4,
+    "edge_cmap": plt.cm.Blues,
+    "with_labels": False,
+}
+nx.draw(G, pos, **options)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_ego_graph.py

@@ -0,0 +1,34 @@
+"""
+=========
+Ego Graph
+=========
+
+Example using the NetworkX ego_graph() function to return the main egonet of
+the largest hub in a Barabási-Albert network.
+"""
+
+from operator import itemgetter
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# Create a BA model graph
+n = 1000
+m = 2
+G = nx.generators.barabasi_albert_graph(n, m)
+
+# find node with largest degree
+node_and_degree = G.degree()
+(largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1]
+
+# Create ego graph of main hub
+hub_ego = nx.ego_graph(G, largest_hub)
+
+# Draw graph
+pos = nx.spring_layout(hub_ego)
+nx.draw(hub_ego, pos, node_color="b", node_size=50, with_labels=False)
+
+# Draw ego as large and red
+options = {"node_size": 300, "node_color": "r"}
+nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], **options)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_four_grids.py

@@ -0,0 +1,29 @@
+"""
+==========
+Four Grids
+==========
+
+Draw a graph with matplotlib.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.grid_2d_graph(4, 4)  # 4x4 grid
+
+pos = nx.spring_layout(G, iterations=100)
+
+plt.subplot(221)
+nx.draw(G, pos, font_size=8)
+
+plt.subplot(222)
+nx.draw(G, pos, node_color="k", node_size=0, with_labels=False)
+
+plt.subplot(223)
+nx.draw(G, pos, node_color="g", node_size=250, with_labels=False, width=6)
+
+plt.subplot(224)
+H = G.to_directed()
+nx.draw(H, pos, node_color="b", node_size=20, with_labels=False)
+
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_giant_component.py

@@ -0,0 +1,51 @@
+"""
+===============
+Giant Component
+===============
+
+This example illustrates the sudden appearance of a
+giant connected component in a binomial random graph.
+"""
+
+import math
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# This example needs Graphviz and either PyGraphviz or pydot.
+# from networkx.drawing.nx_pydot import graphviz_layout as layout
+from networkx.drawing.nx_agraph import graphviz_layout as layout
+
+# If you don't have pygraphviz or pydot, you can do this
+# layout = nx.spring_layout
+
+
+n = 150  # 150 nodes
+# p value at which giant component (of size log(n) nodes) is expected
+p_giant = 1.0 / (n - 1)
+# p value at which graph is expected to become completely connected
+p_conn = math.log(n) / float(n)
+
+# the following range of p values should be close to the threshold
+pvals = [0.003, 0.006, 0.008, 0.015]
+
+region = 220  # for pylab 2x2 subplot layout
+plt.subplots_adjust(left=0, right=1, bottom=0, top=0.95, wspace=0.01, hspace=0.01)
+for p in pvals:
+    G = nx.binomial_graph(n, p)
+    pos = layout(G)
+    region += 1
+    plt.subplot(region)
+    plt.title(f"p = {p:.3f}")
+    nx.draw(G, pos, with_labels=False, node_size=10)
+    # identify largest connected component
+    Gcc = sorted(nx.connected_components(G), key=len, reverse=True)
+    G0 = G.subgraph(Gcc[0])
+    nx.draw_networkx_edges(G0, pos, edge_color="r", width=6.0)
+    # show other connected components
+    for Gi in Gcc[1:]:
+        if len(Gi) > 1:
+            nx.draw_networkx_edges(
+                G.subgraph(Gi), pos, edge_color="r", alpha=0.3, width=5.0,
+            )
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_house_with_colors.py

@@ -0,0 +1,19 @@
+"""
+=================
+House With Colors
+=================
+
+Draw a graph with matplotlib.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.house_graph()
+# explicitly set positions
+pos = {0: (0, 0), 1: (1, 0), 2: (0, 1), 3: (1, 1), 4: (0.5, 2.0)}
+
+nx.draw_networkx_nodes(G, pos, node_size=2000, nodelist=[4])
+nx.draw_networkx_nodes(G, pos, node_size=3000, nodelist=[0, 1, 2, 3], node_color="b")
+nx.draw_networkx_edges(G, pos, alpha=0.5, width=6)
+plt.axis("off")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_knuth_miles.py

@@ -0,0 +1,96 @@
+"""
+===========
+Knuth Miles
+===========
+
+`miles_graph()` returns an undirected graph over the 128 US cities from.  The
+cities each have location and population data.  The edges are labeled with the
+distance between the two cities.
+
+This example is described in Section 1.1 of
+
+    Donald E. Knuth, "The Stanford GraphBase: A Platform for Combinatorial
+    Computing", ACM Press, New York, 1993.
+    http://www-cs-faculty.stanford.edu/~knuth/sgb.html
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/master/examples/drawing/knuth_miles.txt.gz
+"""
+
+import gzip
+import re
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def miles_graph():
+    """ Return the cites example graph in miles_dat.txt
+        from the Stanford GraphBase.
+    """
+    # open file miles_dat.txt.gz (or miles_dat.txt)
+
+    fh = gzip.open("knuth_miles.txt.gz", "r")
+
+    G = nx.Graph()
+    G.position = {}
+    G.population = {}
+
+    cities = []
+    for line in fh.readlines():
+        line = line.decode()
+        if line.startswith("*"):  # skip comments
+            continue
+
+        numfind = re.compile(r"^\d+")
+
+        if numfind.match(line):  # this line is distances
+            dist = line.split()
+            for d in dist:
+                G.add_edge(city, cities[i], weight=int(d))
+                i = i + 1
+        else:  # this line is a city, position, population
+            i = 1
+            (city, coordpop) = line.split("[")
+            cities.insert(0, city)
+            (coord, pop) = coordpop.split("]")
+            (y, x) = coord.split(",")
+
+            G.add_node(city)
+            # assign position - flip x axis for matplotlib, shift origin
+            G.position[city] = (-int(x) + 7500, int(y) - 3000)
+            G.population[city] = float(pop) / 1000.0
+    return G
+
+
+G = miles_graph()
+
+print("Loaded miles_dat.txt containing 128 cities.")
+print(f"digraph has {nx.number_of_nodes(G)} nodes with {nx.number_of_edges(G)} edges")
+
+# make new graph of cites, edge if less then 300 miles between them
+H = nx.Graph()
+for v in G:
+    H.add_node(v)
+for (u, v, d) in G.edges(data=True):
+    if d["weight"] < 300:
+        H.add_edge(u, v)
+
+# draw with matplotlib/pylab
+plt.figure(figsize=(8, 8))
+# with nodes colored by degree sized by population
+node_color = [float(H.degree(v)) for v in H]
+nx.draw(
+    H,
+    G.position,
+    node_size=[G.population[v] for v in H],
+    node_color=node_color,
+    with_labels=False,
+)
+
+# scale the axes equally
+plt.xlim(-5000, 500)
+plt.ylim(-2000, 3500)
+
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_labels_and_colors.py

@@ -0,0 +1,52 @@
+"""
+=================
+Labels And Colors
+=================
+
+Draw a graph with matplotlib, color by degree.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.cubical_graph()
+pos = nx.spring_layout(G)  # positions for all nodes
+
+# nodes
+options = {"node_size": 500, "alpha": 0.8}
+nx.draw_networkx_nodes(G, pos, nodelist=[0, 1, 2, 3], node_color="r", **options)
+nx.draw_networkx_nodes(G, pos, nodelist=[4, 5, 6, 7], node_color="b", **options)
+
+# edges
+nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
+nx.draw_networkx_edges(
+    G,
+    pos,
+    edgelist=[(0, 1), (1, 2), (2, 3), (3, 0)],
+    width=8,
+    alpha=0.5,
+    edge_color="r",
+)
+nx.draw_networkx_edges(
+    G,
+    pos,
+    edgelist=[(4, 5), (5, 6), (6, 7), (7, 4)],
+    width=8,
+    alpha=0.5,
+    edge_color="b",
+)
+
+
+# some math labels
+labels = {}
+labels[0] = r"$a$"
+labels[1] = r"$b$"
+labels[2] = r"$c$"
+labels[3] = r"$d$"
+labels[4] = r"$\alpha$"
+labels[5] = r"$\beta$"
+labels[6] = r"$\gamma$"
+labels[7] = r"$\delta$"
+nx.draw_networkx_labels(G, pos, labels, font_size=16)
+
+plt.axis("off")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_lanl_routes.py

@@ -0,0 +1,65 @@
+"""
+===========
+Lanl Routes
+===========
+
+Routes to LANL from 186 sites on the Internet.
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/master/examples/drawing/lanl_routes.edgelist
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# This example needs Graphviz and either PyGraphviz or pydot
+# from networkx.drawing.nx_pydot import graphviz_layout
+from networkx.drawing.nx_agraph import graphviz_layout
+
+
+def lanl_graph():
+    """ Return the lanl internet view graph from lanl.edges
+    """
+    try:
+        fh = open("lanl_routes.edgelist")
+    except OSError:
+        print("lanl.edges not found")
+        raise
+
+    G = nx.Graph()
+
+    time = {}
+    time[0] = 0  # assign 0 to center node
+    for line in fh.readlines():
+        (head, tail, rtt) = line.split()
+        G.add_edge(int(head), int(tail))
+        time[int(head)] = float(rtt)
+
+    # get largest component and assign ping times to G0time dictionary
+    Gcc = sorted(nx.connected_components(G), key=len, reverse=True)[0]
+    G0 = G.subgraph(Gcc)
+    G0.rtt = {}
+    for n in G0:
+        G0.rtt[n] = time[n]
+
+    return G0
+
+
+G = lanl_graph()
+
+print(f"graph has {nx.number_of_nodes(G)} nodes with {nx.number_of_edges(G)} edges")
+print(nx.number_connected_components(G), "connected components")
+
+plt.figure(figsize=(8, 8))
+# use graphviz to find radial layout
+pos = graphviz_layout(G, prog="twopi", root=0)
+# draw nodes, coloring by rtt ping time
+options = {"with_labels": False, "alpha": 0.5, "node_size": 15}
+nx.draw(G, pos, node_color=[G.rtt[v] for v in G], **options)
+# adjust the plot limits
+xmax = 1.02 * max(xx for xx, yy in pos.values())
+ymax = 1.02 * max(yy for xx, yy in pos.values())
+plt.xlim(0, xmax)
+plt.ylim(0, ymax)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_multipartite_graph.py

@@ -0,0 +1,43 @@
+"""
+===================
+Multipartite Layout
+===================
+"""
+
+import itertools
+import matplotlib.pyplot as plt
+import networkx as nx
+
+from networkx.utils import pairwise
+
+subset_sizes = [5, 5, 4, 3, 2, 4, 4, 3]
+subset_color = [
+    "gold",
+    "violet",
+    "violet",
+    "violet",
+    "violet",
+    "limegreen",
+    "limegreen",
+    "darkorange",
+]
+
+
+def multilayered_graph(*subset_sizes):
+    extents = pairwise(itertools.accumulate((0,) + subset_sizes))
+    layers = [range(start, end) for start, end in extents]
+    G = nx.Graph()
+    for (i, layer) in enumerate(layers):
+        G.add_nodes_from(layer, layer=i)
+    for layer1, layer2 in pairwise(layers):
+        G.add_edges_from(itertools.product(layer1, layer2))
+    return G
+
+
+G = multilayered_graph(*subset_sizes)
+color = [subset_color[data["layer"]] for v, data in G.nodes(data=True)]
+pos = nx.multipartite_layout(G, subset_key="layer")
+plt.figure(figsize=(8, 8))
+nx.draw(G, pos, node_color=color, with_labels=False)
+plt.axis("equal")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_node_colormap.py

@@ -0,0 +1,15 @@
+"""
+=============
+Node Colormap
+=============
+
+Draw a graph with matplotlib, color by degree.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.cycle_graph(24)
+pos = nx.spring_layout(G, iterations=200)
+nx.draw(G, pos, node_color=range(24), node_size=800, cmap=plt.cm.Blues)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_random_geometric_graph.py

@@ -0,0 +1,43 @@
+"""
+======================
+Random Geometric Graph
+======================
+
+Example
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.random_geometric_graph(200, 0.125)
+# position is stored as node attribute data for random_geometric_graph
+pos = nx.get_node_attributes(G, "pos")
+
+# find node near center (0.5,0.5)
+dmin = 1
+ncenter = 0
+for n in pos:
+    x, y = pos[n]
+    d = (x - 0.5) ** 2 + (y - 0.5) ** 2
+    if d < dmin:
+        ncenter = n
+        dmin = d
+
+# color by path length from node near center
+p = dict(nx.single_source_shortest_path_length(G, ncenter))
+
+plt.figure(figsize=(8, 8))
+nx.draw_networkx_edges(G, pos, nodelist=[ncenter], alpha=0.4)
+nx.draw_networkx_nodes(
+    G,
+    pos,
+    nodelist=list(p.keys()),
+    node_size=80,
+    node_color=list(p.values()),
+    cmap=plt.cm.Reds_r,
+)
+
+plt.xlim(-0.05, 1.05)
+plt.ylim(-0.05, 1.05)
+plt.axis("off")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_sampson.py

@@ -0,0 +1,46 @@
+"""
+=======
+Sampson
+=======
+
+Sampson's monastery data.
+
+Shows how to read data from a zip file and plot multiple frames.
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/master/examples/drawing/sampson_data.zip
+"""
+
+import zipfile
+from io import BytesIO as StringIO
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+with zipfile.ZipFile("sampson_data.zip") as zf:
+    e1 = StringIO(zf.read("samplike1.txt"))
+    e2 = StringIO(zf.read("samplike2.txt"))
+    e3 = StringIO(zf.read("samplike3.txt"))
+
+G1 = nx.read_edgelist(e1, delimiter="\t")
+G2 = nx.read_edgelist(e2, delimiter="\t")
+G3 = nx.read_edgelist(e3, delimiter="\t")
+pos = nx.spring_layout(G3, iterations=100)
+plt.clf()
+
+plt.subplot(221)
+plt.title("samplike1")
+nx.draw(G1, pos, node_size=50, with_labels=False)
+plt.subplot(222)
+plt.title("samplike2")
+nx.draw(G2, pos, node_size=50, with_labels=False)
+plt.subplot(223)
+plt.title("samplike3")
+nx.draw(G3, pos, node_size=50, with_labels=False)
+plt.subplot(224)
+plt.title("samplike1,2,3")
+nx.draw(G3, pos, edgelist=list(G3.edges()), node_size=50, with_labels=False)
+nx.draw_networkx_edges(G1, pos, alpha=0.25)
+nx.draw_networkx_edges(G2, pos, alpha=0.25)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_simple_path.py

@@ -0,0 +1,13 @@
+"""
+===========
+Simple Path
+===========
+
+Draw a graph with matplotlib.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.path_graph(8)
+nx.draw(G)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_spectral_grid.py

@@ -0,0 +1,58 @@
+"""
+==================
+Spectral Embedding
+==================
+
+The spectral layout positions the nodes of the graph based on the
+eigenvectors of the graph Laplacian $L = D - A$, where $A$ is the
+adjacency matrix and $D$ is the degree matrix of the graph.
+By default, the spectral layout will embed the graph in two
+dimensions (you can embed your graph in other dimensions using the
+``dim`` argument to either :func:`~drawing.nx_pylab.draw_spectral` or
+:func:`~drawing.layout.spectral_layout`).
+
+When the edges of the graph represent similarity between the incident
+nodes, the spectral embedding will place highly similar nodes closer
+to one another than nodes which are less similar.
+
+This is particularly striking when you spectrally embed a grid
+graph.  In the full grid graph, the nodes in the center of the
+graph are pulled apart more than nodes on the periphery.
+As you remove internal nodes, this effect increases.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+options = {"node_color": "C0", "node_size": 100}
+
+G = nx.grid_2d_graph(6, 6)
+plt.subplot(332)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((2, 2), (2, 3))
+plt.subplot(334)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((3, 2), (3, 3))
+plt.subplot(335)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((2, 2), (3, 2))
+plt.subplot(336)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((2, 3), (3, 3))
+plt.subplot(337)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((1, 2), (1, 3))
+plt.subplot(338)
+nx.draw_spectral(G, **options)
+
+G.remove_edge((4, 2), (4, 3))
+plt.subplot(339)
+nx.draw_spectral(G, **options)
+
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_unix_email.py

@@ -0,0 +1,60 @@
+"""
+==========
+Unix Email
+==========
+
+Create a directed graph, allowing multiple edges and self loops, from a unix
+mailbox.  The nodes are email addresses with links that point from the sender
+to the receivers.  The edge data is a Python email.Message object which
+contains all of the email message data.
+
+This example shows the power of `DiGraph` to hold edge data of arbitrary Python
+objects (in this case a list of email messages).
+
+
+The sample unix email mailbox called "unix_email.mbox" may be found here:
+
+- https://github.com/networkx/networkx/blob/master/examples/drawing/unix_email.mbox
+"""
+
+from email.utils import getaddresses, parseaddr
+import mailbox
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# unix mailbox recipe
+# see https://docs.python.org/3/library/mailbox.html
+
+
+def mbox_graph():
+    mbox = mailbox.mbox("unix_email.mbox")  # parse unix mailbox
+
+    G = nx.MultiDiGraph()  # create empty graph
+
+    # parse each messages and build graph
+    for msg in mbox:  # msg is python email.Message.Message object
+        (source_name, source_addr) = parseaddr(msg["From"])  # sender
+        # get all recipients
+        # see https://docs.python.org/3/library/email.html
+        tos = msg.get_all("to", [])
+        ccs = msg.get_all("cc", [])
+        resent_tos = msg.get_all("resent-to", [])
+        resent_ccs = msg.get_all("resent-cc", [])
+        all_recipients = getaddresses(tos + ccs + resent_tos + resent_ccs)
+        # now add the edges for this mail message
+        for (target_name, target_addr) in all_recipients:
+            G.add_edge(source_addr, target_addr, message=msg)
+
+    return G
+
+
+G = mbox_graph()
+
+# print edges with message subject
+for (u, v, d) in G.edges(data=True):
+    print(f"From: {u} To: {v} Subject: {d['message']['Subject']}")
+
+pos = nx.spring_layout(G, iterations=10)
+nx.draw(G, pos, node_size=0, alpha=0.4, edge_color="r", font_size=16, with_labels=True)
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/plot_weighted_graph.py

@@ -0,0 +1,38 @@
+"""
+==============
+Weighted Graph
+==============
+
+An example using Graph as a weighted network.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.Graph()
+
+G.add_edge("a", "b", weight=0.6)
+G.add_edge("a", "c", weight=0.2)
+G.add_edge("c", "d", weight=0.1)
+G.add_edge("c", "e", weight=0.7)
+G.add_edge("c", "f", weight=0.9)
+G.add_edge("a", "d", weight=0.3)
+
+elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] > 0.5]
+esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] <= 0.5]
+
+pos = nx.spring_layout(G)  # positions for all nodes
+
+# nodes
+nx.draw_networkx_nodes(G, pos, node_size=700)
+
+# edges
+nx.draw_networkx_edges(G, pos, edgelist=elarge, width=6)
+nx.draw_networkx_edges(
+    G, pos, edgelist=esmall, width=6, alpha=0.5, edge_color="b", style="dashed"
+)
+
+# labels
+nx.draw_networkx_labels(G, pos, font_size=20, font_family="sans-serif")
+
+plt.axis("off")
+plt.show()

venv/share/doc/networkx-2.5/examples/drawing/unix_email.mbox

@@ -0,0 +1,84 @@
+From alice@edu  Thu Jun 16 16:12:12 2005
+From: Alice <alice@edu>
+Subject: NetworkX
+Date: Thu, 16 Jun 2005 16:12:13 -0700
+To: Bob <bob@gov>
+Status: RO
+Content-Length: 86
+Lines: 5
+
+Bob, check out the new networkx release - you and
+Carol might really like it.
+
+Alice
+
+
+From bob@gov   Thu Jun 16 18:13:12 2005
+Return-Path: <bob@gov>
+Subject: Re: NetworkX
+From: Bob <bob@gov>
+To: Alice <alice@edu>
+Content-Type: text/plain
+Date: Thu, 16 Jun 2005 18:13:12 -0700
+Status: RO
+Content-Length: 26
+Lines: 4
+
+Thanks for the tip.
+
+Bob
+
+
+From ted@com  Thu Jul 28 09:53:31 2005
+Return-Path: <ted@com>
+Subject: Graph package in Python?
+From: Ted <ted@com>
+To: Bob <bob@gov>
+Content-Type: text/plain
+Date: Thu, 28 Jul 2005 09:47:03 -0700
+Status: RO
+Content-Length: 90
+Lines: 3
+
+Hey Ted - I'm looking for a Python package for
+graphs and networks.  Do you know of any?
+
+
+From bob@gov  Thu Jul 28 09:59:31 2005
+Return-Path: <bob@gov>
+Subject: Re: Graph package in Python?
+From: Bob <bob@gov>
+To: Ted <ted@com>
+Content-Type: text/plain
+Date: Thu, 28 Jul 2005 09:59:03 -0700
+Status: RO
+Content-Length: 180
+Lines: 9
+
+
+Check out the NetworkX package - Alice sent me the tip!
+
+Bob
+
+>> bob@gov scrawled:
+>> Hey Ted - I'm looking for a Python package for
+>> graphs and networks.  Do you know of any?
+
+
+From ted@com  Thu Jul 28 15:53:31 2005
+Return-Path: <ted@com>
+Subject: get together for lunch to discuss Networks?
+From: Ted <ted@com>
+To: Bob <bob@gov>, Carol <carol@gov>, Alice <alice@edu>
+Content-Type: text/plain
+Date: Thu, 28 Jul 2005 15:47:03 -0700
+Status: RO
+Content-Length: 139
+Lines: 5
+
+Hey everyrone!  Want to meet at that restaurant on the
+island in Konigsburg tonight?  Bring your laptops
+and we can install NetworkX.
+
+Ted
+