Fixed database typo and removed unnecessary class identifier.

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

@@ -0,0 +1,2 @@
+Graph
+-----

venv/share/doc/networkx-2.5/examples/graph/dot_atlas.py

@@ -0,0 +1,25 @@
+"""
+======
+Atlas2
+======
+
+Write first 20 graphs from the graph atlas as graphviz dot files
+Gn.dot where n=0,19.
+"""
+
+import networkx as nx
+from networkx.generators.atlas import graph_atlas_g
+
+atlas = graph_atlas_g()[0:20]
+
+for G in atlas:
+    print(
+        f"{G.name} has {nx.number_of_nodes(G)} nodes with {nx.number_of_edges(G)} edges"
+    )
+    A = nx.nx_agraph.to_agraph(G)
+    A.graph_attr["label"] = G.name
+    # set default node attributes
+    A.node_attr["color"] = "red"
+    A.node_attr["style"] = "filled"
+    A.node_attr["shape"] = "circle"
+    A.write(G.name + ".dot")

venv/share/doc/networkx-2.5/examples/graph/plot_degree_sequence.py

@@ -0,0 +1,30 @@
+"""
+===============
+Degree Sequence
+===============
+
+Random graph from given degree sequence.
+"""
+import matplotlib.pyplot as plt
+from networkx import nx
+
+z = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
+print(nx.is_graphical(z))
+
+print("Configuration model")
+G = nx.configuration_model(z)  # configuration model
+degree_sequence = [d for n, d in G.degree()]  # degree sequence
+print(f"Degree sequence {degree_sequence}")
+print("Degree histogram")
+hist = {}
+for d in degree_sequence:
+    if d in hist:
+        hist[d] += 1
+    else:
+        hist[d] = 1
+print("degree #nodes")
+for d in hist:
+    print(f"{d:4} {hist[d]:6}")
+
+nx.draw(G)
+plt.show()

venv/share/doc/networkx-2.5/examples/graph/plot_erdos_renyi.py

@@ -0,0 +1,33 @@
+"""
+===========
+Erdos Renyi
+===========
+
+Create an G{n,m} random graph with n nodes and m edges
+and report some properties.
+
+This graph is sometimes called the Erdős-Rényi graph
+but is different from G{n,p} or binomial_graph which is also
+sometimes called the Erdős-Rényi graph.
+"""
+
+import matplotlib.pyplot as plt
+from networkx import nx
+
+n = 10  # 10 nodes
+m = 20  # 20 edges
+
+G = nx.gnm_random_graph(n, m)
+
+# some properties
+print("node degree clustering")
+for v in nx.nodes(G):
+    print(f"{v} {nx.degree(G, v)} {nx.clustering(G, v)}")
+
+print()
+print("the adjacency list")
+for line in nx.generate_adjlist(G):
+    print(line)
+
+nx.draw(G)
+plt.show()

venv/share/doc/networkx-2.5/examples/graph/plot_expected_degree_sequence.py

@@ -0,0 +1,21 @@
+"""
+========================
+Expected Degree Sequence
+========================
+
+Random graph from given degree sequence.
+"""
+
+import networkx as nx
+from networkx.generators.degree_seq import expected_degree_graph
+
+# make a random graph of 500 nodes with expected degrees of 50
+n = 500  # n nodes
+p = 0.1
+w = [p * n for i in range(n)]  # w = p*n for all nodes
+G = expected_degree_graph(w)  # configuration model
+print("Degree histogram")
+print("degree (#nodes) ****")
+dh = nx.degree_histogram(G)
+for i, d in enumerate(dh):
+    print(f"{i:2} ({d:2}) {'*'*d}")

venv/share/doc/networkx-2.5/examples/graph/plot_football.py

@@ -0,0 +1,47 @@
+"""
+========
+Football
+========
+
+Load football network in GML format and compute some network statistcs.
+
+Shows how to download GML graph in a zipped file, unpack it, and load
+into a NetworkX graph.
+
+Requires Internet connection to download the URL
+http://www-personal.umich.edu/~mejn/netdata/football.zip
+"""
+
+import urllib.request as urllib
+import io
+import zipfile
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+url = "http://www-personal.umich.edu/~mejn/netdata/football.zip"
+
+sock = urllib.urlopen(url)  # open URL
+s = io.BytesIO(sock.read())  # read into BytesIO "file"
+sock.close()
+
+zf = zipfile.ZipFile(s)  # zipfile object
+txt = zf.read("football.txt").decode()  # read info file
+gml = zf.read("football.gml").decode()  # read gml data
+# throw away bogus first line with # from mejn files
+gml = gml.split("\n")[1:]
+G = nx.parse_gml(gml)  # parse gml data
+
+print(txt)
+# print degree for each team - number of games
+for n, d in G.degree():
+    print(f"{n:20} {d:2}")
+
+options = {
+    "node_color": "black",
+    "node_size": 50,
+    "linewidths": 0,
+    "width": 0.1,
+}
+nx.draw(G, **options)
+plt.show()

venv/share/doc/networkx-2.5/examples/graph/plot_karate_club.py

@@ -0,0 +1,25 @@
+"""
+===========
+Karate Club
+===========
+
+Zachary's Karate Club graph
+
+Data file from:
+http://vlado.fmf.uni-lj.si/pub/networks/data/Ucinet/UciData.htm
+
+Zachary W. (1977).
+An information flow model for conflict and fission in small groups.
+Journal of Anthropological Research, 33, 452-473.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.karate_club_graph()
+print("Node Degree")
+for v in G:
+    print(f"{v:4} {G.degree(v):6}")
+
+nx.draw_circular(G, with_labels=True)
+plt.show()

venv/share/doc/networkx-2.5/examples/graph/plot_napoleon_russian_campaign.py

@@ -0,0 +1,134 @@
+"""
+=========================
+Napoleon Russian Campaign
+=========================
+
+Minard's data from Napoleon's 1812-1813  Russian Campaign.
+http://www.math.yorku.ca/SCS/Gallery/minard/minard.txt
+
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def minard_graph():
+    data1 = """\
+24.0,54.9,340000,A,1
+24.5,55.0,340000,A,1
+25.5,54.5,340000,A,1
+26.0,54.7,320000,A,1
+27.0,54.8,300000,A,1
+28.0,54.9,280000,A,1
+28.5,55.0,240000,A,1
+29.0,55.1,210000,A,1
+30.0,55.2,180000,A,1
+30.3,55.3,175000,A,1
+32.0,54.8,145000,A,1
+33.2,54.9,140000,A,1
+34.4,55.5,127100,A,1
+35.5,55.4,100000,A,1
+36.0,55.5,100000,A,1
+37.6,55.8,100000,A,1
+37.7,55.7,100000,R,1
+37.5,55.7,98000,R,1
+37.0,55.0,97000,R,1
+36.8,55.0,96000,R,1
+35.4,55.3,87000,R,1
+34.3,55.2,55000,R,1
+33.3,54.8,37000,R,1
+32.0,54.6,24000,R,1
+30.4,54.4,20000,R,1
+29.2,54.3,20000,R,1
+28.5,54.2,20000,R,1
+28.3,54.3,20000,R,1
+27.5,54.5,20000,R,1
+26.8,54.3,12000,R,1
+26.4,54.4,14000,R,1
+25.0,54.4,8000,R,1
+24.4,54.4,4000,R,1
+24.2,54.4,4000,R,1
+24.1,54.4,4000,R,1"""
+    data2 = """\
+24.0,55.1,60000,A,2
+24.5,55.2,60000,A,2
+25.5,54.7,60000,A,2
+26.6,55.7,40000,A,2
+27.4,55.6,33000,A,2
+28.7,55.5,33000,R,2
+29.2,54.2,30000,R,2
+28.5,54.1,30000,R,2
+28.3,54.2,28000,R,2"""
+    data3 = """\
+24.0,55.2,22000,A,3
+24.5,55.3,22000,A,3
+24.6,55.8,6000,A,3
+24.6,55.8,6000,R,3
+24.2,54.4,6000,R,3
+24.1,54.4,6000,R,3"""
+    cities = """\
+24.0,55.0,Kowno
+25.3,54.7,Wilna
+26.4,54.4,Smorgoni
+26.8,54.3,Moiodexno
+27.7,55.2,Gloubokoe
+27.6,53.9,Minsk
+28.5,54.3,Studienska
+28.7,55.5,Polotzk
+29.2,54.4,Bobr
+30.2,55.3,Witebsk
+30.4,54.5,Orscha
+30.4,53.9,Mohilow
+32.0,54.8,Smolensk
+33.2,54.9,Dorogobouge
+34.3,55.2,Wixma
+34.4,55.5,Chjat
+36.0,55.5,Mojaisk
+37.6,55.8,Moscou
+36.6,55.3,Tarantino
+36.5,55.0,Malo-Jarosewii"""
+
+    c = {}
+    for line in cities.split("\n"):
+        x, y, name = line.split(",")
+        c[name] = (float(x), float(y))
+
+    g = []
+
+    for data in [data1, data2, data3]:
+        G = nx.Graph()
+        i = 0
+        G.pos = {}  # location
+        G.pop = {}  # size
+        last = None
+        for line in data.split("\n"):
+            x, y, p, r, n = line.split(",")
+            G.pos[i] = (float(x), float(y))
+            G.pop[i] = int(p)
+            if last is None:
+                last = i
+            else:
+                G.add_edge(i, last, **{r: int(n)})
+                last = i
+            i = i + 1
+        g.append(G)
+
+    return g, c
+
+
+(g, city) = minard_graph()
+
+plt.figure(1, figsize=(11, 5))
+plt.clf()
+colors = ["b", "g", "r"]
+for G in g:
+    c = colors.pop(0)
+    node_size = [int(G.pop[n] / 300.0) for n in G]
+    nx.draw_networkx_edges(G, G.pos, edge_color=c, width=4, alpha=0.5)
+    nx.draw_networkx_nodes(G, G.pos, node_size=node_size, node_color=c, alpha=0.5)
+    nx.draw_networkx_nodes(G, G.pos, node_size=5, node_color="k")
+
+for c in city:
+    x, y = city[c]
+    plt.text(x, y + 0.1, c)
+plt.show()

venv/share/doc/networkx-2.5/examples/graph/plot_roget.py

@@ -0,0 +1,80 @@
+"""
+=====
+Roget
+=====
+
+Build a directed graph of 1022 categories and 5075 cross-references as defined
+in the 1879 version of Roget's Thesaurus. This example is described in Section
+1.2 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
+
+Note that one of the 5075 cross references is a self loop yet it is included in
+the graph built here because the standard networkx `DiGraph` class allows self
+loops.  (cf. 400pungency:400 401 403 405).
+
+The data file can be found at:
+
+- https://github.com/networkx/networkx/blob/master/examples/graph/roget_dat.txt.gz
+"""
+
+import gzip
+import re
+import sys
+
+import matplotlib.pyplot as plt
+from networkx import nx
+
+
+def roget_graph():
+    """ Return the thesaurus graph from the roget.dat example in
+    the Stanford Graph Base.
+    """
+    # open file roget_dat.txt.gz
+    fh = gzip.open("roget_dat.txt.gz", "r")
+
+    G = nx.DiGraph()
+
+    for line in fh.readlines():
+        line = line.decode()
+        if line.startswith("*"):  # skip comments
+            continue
+        if line.startswith(" "):  # this is a continuation line, append
+            line = oldline + line
+        if line.endswith("\\\n"):  # continuation line, buffer, goto next
+            oldline = line.strip("\\\n")
+            continue
+
+        (headname, tails) = line.split(":")
+
+        # head
+        numfind = re.compile(r"^\d+")  # re to find the number of this word
+        head = numfind.findall(headname)[0]  # get the number
+
+        G.add_node(head)
+
+        for tail in tails.split():
+            if head == tail:
+                print("skipping self loop", head, tail, file=sys.stderr)
+            G.add_edge(head, tail)
+
+    return G
+
+
+G = roget_graph()
+print("Loaded roget_dat.txt containing 1022 categories.")
+print(f"digraph has {nx.number_of_nodes(G)} nodes with {nx.number_of_edges(G)} edges")
+UG = G.to_undirected()
+print(nx.number_connected_components(UG), "connected components")
+
+options = {
+    "node_color": "black",
+    "node_size": 1,
+    "edge_color": "gray",
+    "linewidths": 0,
+    "width": 0.1,
+}
+nx.draw_circular(UG, **options)
+plt.show()

venv/share/doc/networkx-2.5/examples/graph/plot_words.py

@@ -0,0 +1,74 @@
+"""
+==================
+Words/Ladder Graph
+==================
+
+Generate  an undirected graph over the 5757 5-letter words in the datafile
+`words_dat.txt.gz`.  Two words are connected by an edge if they differ in one
+letter, resulting in 14,135 edges. 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/graph/words_dat.txt.gz
+"""
+
+import gzip
+from string import ascii_lowercase as lowercase
+
+import networkx as nx
+
+
+def generate_graph(words):
+    G = nx.Graph(name="words")
+    lookup = {c: lowercase.index(c) for c in lowercase}
+
+    def edit_distance_one(word):
+        for i in range(len(word)):
+            left, c, right = word[0:i], word[i], word[i + 1 :]
+            j = lookup[c]  # lowercase.index(c)
+            for cc in lowercase[j + 1 :]:
+                yield left + cc + right
+
+    candgen = (
+        (word, cand)
+        for word in sorted(words)
+        for cand in edit_distance_one(word)
+        if cand in words
+    )
+    G.add_nodes_from(words)
+    for word, cand in candgen:
+        G.add_edge(word, cand)
+    return G
+
+
+def words_graph():
+    """Return the words example graph from the Stanford GraphBase"""
+    fh = gzip.open("words_dat.txt.gz", "r")
+    words = set()
+    for line in fh.readlines():
+        line = line.decode()
+        if line.startswith("*"):
+            continue
+        w = str(line[0:5])
+        words.add(w)
+    return generate_graph(words)
+
+
+G = words_graph()
+print("Loaded words_dat.txt containing 5757 five-letter English words.")
+print("Two words are connected if they differ in one letter.")
+print(f"Graph has {nx.number_of_nodes(G)} nodes with {nx.number_of_edges(G)} edges")
+print(f"{nx.number_connected_components(G)} connected components")
+
+for (source, target) in [("chaos", "order"), ("nodes", "graph"), ("pound", "marks")]:
+    print(f"Shortest path between {source} and {target} is")
+    try:
+        sp = nx.shortest_path(G, source, target)
+        for n in sp:
+            print(n)
+    except nx.NetworkXNoPath:
+        print("None")