Align better with WMA

Graph Construction & Representation:
https://reference.wolfram.com/language/guide/GraphConstructionAndRepresentation.html

Move eval stuff to pymathics.graph.eval

Author: rocky

pymathics/graph/__init__.py

@@ -61,7 +61,9 @@
     WeaklyConnectedComponents,
 )
 
-from pymathics.graph.generators import (
+from pymathics.graph.curated import GraphData
+
+from pymathics.graph.parametric import (
     BalancedTree,
     BarbellGraph,
     BinomialTree,
@@ -70,17 +72,18 @@
     CycleGraph,
     FullRAryTree,
     GraphAtlas,
-    GraphData,
     HknHararyGraph,
     HmnHararyGraph,
     KaryTree,
     LadderGraph,
-    PathGraph,
-    RandomGraph,
     RandomTree,
     StarGraph,
 )
-from pymathics.graph.tree import TreeGraphAtom, TreeGraph, TreeGraphQ
+
+from pymathics.graph.random import RandomGraph
+
+from pymathics.graph.structured import PathGraph, TreeGraph
+from pymathics.graph.tree import TreeGraphAtom, TreeGraphQ
 from pymathics.graph.version import __version__
 
 pymathics_version_data = {

pymathics/graph/algorithms.py

@@ -3,6 +3,8 @@
 Algorithms on Graphs
 """
 
+import networkx as nx
+
 from typing import Optional
 
 from mathics.core.atoms import Integer1, Integer2, Integer3
@@ -20,7 +22,6 @@
     SymbolUndirectedEdge,
     _create_graph,
     _NetworkXBuiltin,
-    nx,
 )
 
 
@@ -89,7 +90,7 @@ class GraphDistance(_NetworkXBuiltin):
 
     <dl>
       <dt>'GraphDistance[{$v$->$w$, ...}, ...]'
-      <dd>use rules $v$->$w$ to specify the graph $g$
+      <dd>use rules $v$->$w$ to specify the graph $g$.
     </dl>
 
     >> GraphDistance[{1 <-> 2, 2 <-> 3, 3 <-> 4, 2 <-> 4, 4 -> 5}, 1, 5]

pymathics/graph/base.py

@@ -11,10 +11,11 @@
 
 from collections import defaultdict
 from inspect import isgenerator
+from typing import Callable, Optional
 
 from mathics.builtin.base import AtomBuiltin, Builtin
 from mathics.builtin.box.graphics import GraphicsBox
-from mathics.core.atoms import Atom, Integer, Integer0, Integer1, Integer2, Real
+from mathics.core.atoms import Atom, Integer, Integer0, Integer1, Integer2, Real, String
 from mathics.core.convert.expression import ListExpression, from_python
 from mathics.core.element import BaseElement
 from mathics.core.expression import Expression
@@ -80,6 +81,37 @@
 import networkx as nx
 
 
+def graph_helper(
+    graph_generator_func: Callable,
+    options: dict,
+    can_digraph: bool,
+    graph_layout: str,
+    evaluation,
+    root: Optional[int] = None,
+    *args,
+    **kwargs,
+) -> Optional[Callable]:
+    should_digraph = can_digraph and has_directed_option(options)
+    try:
+        G = (
+            graph_generator_func(*args, create_using=nx.DiGraph, **kwargs)
+            if should_digraph
+            else graph_generator_func(*args, **kwargs)
+        )
+    except MemoryError:
+        evaluation.message("Graph", "mem", evaluation)
+        return None
+    if graph_layout and not options["System`GraphLayout"].get_string_value():
+        options["System`GraphLayout"] = String(graph_layout)
+
+    g = Graph(G)
+    _process_graph_options(g, options)
+
+    if root is not None:
+        G.root = g.root = root
+    return g
+
+
 def has_directed_option(options: dict) -> bool:
     return options.get("System`DirectedEdges", False).to_python()
 
@@ -816,9 +848,7 @@ def track_edges(*edges):
             multigraph[0] = True
 
     edge_weights = _edge_weights(options)
-    use_directed_edges = (
-        options.get("System`DirectedEdges", SymbolTrue) is SymbolTrue
-    )
+    use_directed_edges = options.get("System`DirectedEdges", SymbolTrue) is SymbolTrue
 
     directed_edge_head = (
         SymbolDirectedEdge if use_directed_edges else SymbolUndirectedEdge
@@ -903,7 +933,7 @@ def full_new_edge_properties(new_edge_style):
         edge_properties = list(full_new_edge_properties(edge_options))
         for edge, attr_dict in zip(new_edges, edge_properties):
             parse_edge(edge, attr_dict)
-    except _GraphParseError as e:
+    except _GraphParseError:
         return None
 
     empty_dict = {}
@@ -947,7 +977,9 @@ def full_new_edge_properties(new_edge_style):
 
 
 class _Centrality(_NetworkXBuiltin):
-    options ={"WorkingPrecision": "MachinePrecision",}
+    options = {
+        "WorkingPrecision": "MachinePrecision",
+    }
     pass
 
 
@@ -1320,8 +1352,9 @@ class EdgeRules(_NetworkXBuiltin):
       <dd> gives the list of edge rules for the graph $g$.
     </dl>
     """
+
     summary_text = "list the edge rules"
-    
+
     def eval(self, graph, expression, evaluation, options):
         "%(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
@@ -1341,7 +1374,7 @@ class EigenvectorCentrality(_ComponentwiseCentrality):
     https://en.wikipedia.org/wiki/Eigenvector_centrality</url> (<url>
     :Networkx:
     https://networkx.org/documentation/networkx-2.8.8/reference/algorithms\
-/generated/networkx.algorithms.centrality.eigenvector_centrality.html</url>, 
+/generated/networkx.algorithms.centrality.eigenvector_centrality.html</url>,
 <url>
     :WMA:
     https://reference.wolfram.com/language/ref/EgenvectorCentrality.html</url>)
@@ -1378,7 +1411,7 @@ class EigenvectorCentrality(_ComponentwiseCentrality):
     """
 
     summary_text = "compute the eigenvector centralities"
-    
+
     def _centrality(self, g, weight):
         return nx.eigenvector_centrality(g, max_iter=10000, tol=1.0e-7, weight=weight)
 
@@ -1466,7 +1499,7 @@ class FindVertexCut(_NetworkXBuiltin):
     """
 
     summary_text = "find the vertex cuts"
-    
+
     def eval(self, graph, expression, evaluation, options):
         "FindVertexCut[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
@@ -1573,7 +1606,7 @@ class HITSCentrality(_Centrality):
     https://en.wikipedia.org/wiki/HITS_centrality</url> (<url>
     :Networkx:
     https://networkx.org/documentation/networkx-2.8.8/reference/algorithms/\
-generated/networkx.algorithms.link_analysis.hits_alg.hits.html</url>, 
+generated/networkx.algorithms.link_analysis.hits_alg.hits.html</url>,
     <url>
     :WMA:
     https://reference.wolfram.com/language/ref/HITSCentrality.html</url>)
@@ -1652,7 +1685,7 @@ class KatzCentrality(_ComponentwiseCentrality):
     <dl>
       <dt>'KatzCentrality'[$g$, $alpha$]
       <dd>gives a list of Katz centralities for the \
-          vertices in the graph $g$ and weight $alpha$.       
+          vertices in the graph $g$ and weight $alpha$.
       <dt>'KatzCentrality'[$g$, $alpha$, $beta$]
       <dd>gives a list of Katz centralities for the \
           vertices in the graph $g$ and weight $alpha$ and initial centralities $beta$.
@@ -1673,7 +1706,7 @@ class KatzCentrality(_ComponentwiseCentrality):
     """
 
     summary_text = "Katz centrality"
-    
+
     rules = {
         "Pymathics`KatzCentrality[Pymathics`g_, Pymathics`alpha_]": "Pymathics`KatzCentrality[Pymathics`g, Pymathics`alpha, 1]",
     }
@@ -2073,7 +2106,7 @@ class UndirectedEdge(Builtin):
     >> a <-> (b <-> c)
      = UndirectedEdge[a, UndirectedEdge[b, c]]
     """
-    
+
     summary_text = "makes undirected graph edge"
     pass
 

pymathics/graph/curated.py

@@ -0,0 +1,56 @@
+"""
+Curated Graphs
+"""
+
+import networkx as nx
+
+from mathics.core.evaluation import Evaluation
+
+from pymathics.graph.base import (
+    Graph,
+    _NetworkXBuiltin,
+    graph_helper,
+)
+
+
+class GraphData(_NetworkXBuiltin):
+    """
+    <dl>
+      <dt>'GraphData[$name$]'
+      <dd>Returns a graph with the specified name.
+    </dl>
+
+    >> GraphData["PappusGraph"]
+    """
+
+    def eval(self, name, expression, evaluation: Evaluation, options: dict) -> Graph:
+        "GraphData[name_String, OptionsPattern[GraphData]]"
+        py_name = name.get_string_value()
+        fn, layout = WL_TO_NETWORKX_FN.get(py_name, (None, None))
+        if not fn:
+            if not py_name.endswith("_graph"):
+                py_name += "_graph"
+            if py_name in ("LCF_graph", "make_small_graph"):
+                # These graphs require parameters
+                return
+            import inspect
+
+            fn = dict(inspect.getmembers(nx, inspect.isfunction)).get(py_name, None)
+            # parameters = inspect.signature(nx.diamond_graph).parameters.values()
+            # if len([p for p in list(parameters) if p.kind in [inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD]]) != 0:
+            #     return
+        if fn:
+            g = graph_helper(fn, options, False, evaluation, layout)
+            g.G.name = py_name
+            return g
+
+
+WL_TO_NETWORKX_FN = {
+    "DodecahedralGraph": (nx.dodecahedral_graph, None),
+    "DiamondGraph": (nx.diamond_graph, "spring"),
+    "PappusGraph": (nx.pappus_graph, "circular"),
+    "IsohedralGraph": (nx.icosahedral_graph, "spring"),
+    "PetersenGraph": (nx.petersen_graph, None),
+}
+
+# TODO: ExampleData

pymathics/graph/eval/__init__.py

@@ -19,8 +19,6 @@
 import networkx as nx
 from networkx.exception import NetworkXError
 
-__all__ = ["hnm_harary_graph", "hkn_harary_graph"]
-
 
 def hnm_harary_graph(n, m, create_using=None):
     """Returns the Harary graph with given numbers of nodes and edges.

pymathics/graph/harary.py pymathics/graph/eval/harary.pypymathics/graph/harary.py renamed to pymathics/graph/eval/harary.py

@@ -0,0 +1,83 @@
+"""
+evaluation methods for Parametric Graphs
+"""
+
+import networkx as nx
+from typing import Optional
+
+from mathics.core.atoms import Integer
+from mathics.core.evaluation import Evaluation
+from pymathics.graph.base import Graph, graph_helper
+from pymathics.graph.eval.harary import hkn_harary_graph
+
+
+def eval_complete_graph(
+    self, n: Integer, expression, evaluation: Evaluation, options: dict
+) -> Optional[Graph]:
+    py_n = n.value
+
+    if py_n < 1:
+        evaluation.message(self.get_name(), "ilsmp", expression)
+        return
+
+    args = (py_n,)
+    g = graph_helper(
+        nx.complete_graph, options, False, "circular", evaluation, None, *args
+    )
+    if not g:
+        return None
+
+    g.G.n = n
+    return g
+
+
+def eval_full_rary_tree(
+    self, r: Integer, n: Integer, expression, evaluation: Evaluation, options: dict
+) -> Optional[Graph]:
+    """
+    Call networkx to get a full_raray_tree using parameters, ``r`` and ``t``.
+    """
+    py_r = r.value
+
+    if py_r < 0:
+        evaluation.message(self.get_name(), "ilsmp", expression)
+        return
+
+    py_n = n.value
+    if py_n < 0:
+        evaluation.message(self.get_name(), "ilsmp", expression)
+        return
+
+    args = (py_r, py_n)
+    g = graph_helper(nx.full_rary_tree, options, True, "tree", evaluation, 0, *args)
+    if not g:
+        return None
+
+    g.G.r = r
+    g.G.n = n
+    return g
+
+
+def eval_hkn_harary(
+    self, k: Integer, n: Integer, expression, evaluation: Evaluation, options: dict
+) -> Optional[Graph]:
+    py_k = k.value
+
+    if py_k < 0:
+        evaluation.message(self.get_name(), "ilsmp", expression)
+        return
+
+    py_n = n.value
+    if py_n < 0:
+        evaluation.message(self.get_name(), "ilsmp2", expression)
+        return
+
+    args = (py_k, py_n)
+    g = graph_helper(
+        hkn_harary_graph, options, False, "circular", evaluation, None, *args
+    )
+    if not g:
+        return None
+    g.k = py_k
+    g.n = py_n
+    return g