Improving create graph (#10)

* fix Characterencoding

* fixes in creating graph

* importing unlisted symbols

* KatzCentrality

---------

Co-authored-by: rocky <[email protected]>

Author: mmatera

Makefile

@@ -10,8 +10,6 @@ PIP ?= $(PYTHON) -m pip
 RM  ?= rm
 
 
-
-
 .PHONY: all build \
    check clean \
    develop dist doc doc-data \
@@ -54,7 +52,7 @@ clean-pyc:
 
 #: Run py.test tests. Use environment variable "o" for pytest options
 pytest:
-	$(PYTHON) -m pytest test $o
+	MATHICS_CHARACTER_ENCODING="ASCII" $(PYTHON) -m pytest $(PYTEST_WORKERS) test $o
 
 
 # #: Create data that is used to in Django docs and to build TeX PDF

pymathics/graph/__init__.py

@@ -14,6 +14,7 @@
 """
 
 from pymathics.graph.base import (
+    AdjacencyList,
     AcyclicGraphQ,
     BetweennessCentrality,
     ClosenessCentrality,
@@ -69,6 +70,7 @@
     CycleGraph,
     FullRAryTree,
     GraphAtlas,
+    GraphData,
     HknHararyGraph,
     HmnHararyGraph,
     KaryTree,
@@ -91,6 +93,7 @@
 # Thsee are the publicly exported names
 __all__ = [
     "AcyclicGraphQ",
+    "AdjacencyList",
     "BalancedTree",
     "BarbellGraph",
     "BetweennessCentrality",
@@ -118,6 +121,7 @@
     "GraphAtlas",
     "GraphAtom",
     "GraphBox",
+    "GraphData",
     "GraphDistance",
     "HITSCentrality",
     "HighlightGraph",

pymathics/graph/base.py

@@ -423,7 +423,7 @@ class _FullGraphRewrite(Exception):
 
 def _normalize_edges(edges):
     for edge in edges:
-        if edge.has_form("Property", 2):
+        if edge.has_form("Pymathics`Property", 2):
             expr, prop = edge.elements
             yield Expression(edge.get_head(), list(_normalize_edges([expr]))[0], prop)
         elif edge.get_head_name() == "System`Rule":
@@ -726,7 +726,8 @@ def _graph_from_list(rules, options, new_vertices=None):
 def _create_graph(
     new_edges, new_edge_properties, options, from_graph=None, new_vertices=None
 ):
-
+    vertices_dict = {}
+    # Classification of vertex and edges
     known_vertices = set()
     vertices = []
     vertex_properties = []
@@ -745,9 +746,6 @@ def add_vertex(x, attr_dict=None):
     directed_edges = []
     undirected_edges = []
 
-    if new_vertices is not None:
-        vertices = [add_vertex(v) for v in new_vertices]
-
     if from_graph is not None:
         old_vertices = dict(from_graph.nodes.data())
         vertices += old_vertices
@@ -767,6 +765,31 @@ def add_vertex(x, attr_dict=None):
 
         multigraph = [False]
 
+
+    if new_vertices is not None:
+        for v in new_vertices:
+            add_vertex(v) 
+
+    def add_vertex(x, attr_dict=None):
+        if attr_dict is None:
+            attr_dict = {}
+        if x.has_form("Pymathics`Property", 2):
+            expr, prop = x.elements
+            attr_dict.update(_parse_property(prop, attr_dict))
+            return add_vertex(expr, attr_dict)
+        elif x not in known_vertices:
+            known_vertices.add(x)
+            vertices.append(x)
+            vertex_properties.append(attr_dict)
+            vertices_dict[x] = attr_dict
+        else:
+            vertices_dict[x].update(attr_dict)
+        return x
+
+    if new_vertices is not None:
+        for v in new_vertices:
+            add_vertex(v)
+
     known_edges = set(edges)
     # It is simpler to just recompute this than change the above to work
     # incrementally
@@ -788,12 +811,28 @@ def track_edges(*edges):
         SymbolDirectedEdge if use_directed_edges else SymbolUndirectedEdge
     )
 
-    def parse_edge(r, attr_dict):
+    def parse_edge(r, attr_dict=None):
+        if attr_dict is None:
+            attr_dict = {}
+
         if isinstance(r, Atom):
             raise _GraphParseError(
                 msg=f"{r} is an atom, and hence does not define an edge."
             )
 
+        if r.has_form("Pymathics`Property", None):
+            expr, prop = r.elements
+            attr_dict.update(_parse_property(prop, attr_dict))
+            return parse_edge(expr, attr_dict)
+
+
+        if r.head not in (SymbolRule, SymbolDirectedEdge, SymbolUndirectedEdge):
+            raise _GraphParseError(
+                msg=f"{r} is not an edge description."
+            )
+
+
+            
         name = r.get_head_name()
         elements = r.elements
 
@@ -1138,7 +1177,6 @@ class DegreeCentrality(_Centrality):
 
     def _from_dict(self, graph, centrality):
         s = len(graph.G) - 1  # undo networkx's normalization
-        print("_from_dict", (graph, type(graph)))
         return ListExpression(
             *[Integer(s * centrality.get(v, 0)) for v in graph.vertices],
         )
@@ -1274,7 +1312,6 @@ def eval(self, graph, expression, evaluation, options):
         if graph:
 
             def rules():
-                print("Looking for Edge rules")
                 for edge in graph.edges:
                     u, v = edge
                     yield Expression(SymbolRule, u, v)
@@ -1566,7 +1603,7 @@ class KatzCentrality(_ComponentwiseCentrality):
     """
 
     rules = {
-        "KatzCentrality[g_, alpha_]": "KatzCentrality[g, alpha, 1]",
+        "Pymathics`KatzCentrality[g_, Pymathics`alpha_]": "Pymathics`KatzCentrality[g, Pymathics`alpha, 1]",
     }
 
     def _centrality(self, g, weight, alpha, beta):
@@ -1575,11 +1612,16 @@ def _centrality(self, g, weight, alpha, beta):
         )
 
     def eval(self, graph, alpha, beta, expression, evaluation, options):
-        "%(name)s[graph_, alpha_, beta_, OptionsPattern[%(name)s]]"
+        "Pymathics`KatzCentrality[graph_, alpha_, beta_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
+        print("Katz graph", graph)
         if graph:
-            py_alpha = alpha.to_mpmath()
-            py_beta = beta.to_mpmath()
+            print([alpha, beta, type(alpha), type(beta)])
+            try:
+                py_alpha = alpha.to_mpmath()
+                py_beta = beta.to_mpmath()
+            except NotImplementedError:
+                return
             if py_alpha is None or py_beta is None:
                 return
             return self._compute(
@@ -1639,6 +1681,7 @@ def eval(self, graph, expression, evaluation, options):
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if graph:
             return from_python(graph.is_mixed_graph())
+        return SymbolFalse
 
 
 class MultigraphQ(_NetworkXBuiltin):
@@ -1757,14 +1800,21 @@ class PropertyValue(Builtin):
 
     def eval(self, graph, item, name, evaluation):
         "PropertyValue[{graph_Graph, item_}, name_Symbol]"
+        name_str = name.get_name()
         if isinstance(graph, Graph):
-            try:
-                # Fixme: this does not work...
-                value = graph.G.get_property(item, name.get_name())
-            except:
-                return SymbolFailed
-            if value is None:
+            if (
+                item.has_form("Rule", 2)
+                or item.has_form("DirectedEdge", 2)
+                or item.has_form("UndirectedEdge", 2)
+            ):
+                item_g = graph.G.edges().get(item.elements)
+            else:
+                item_g = graph.G.nodes().get(item)
+
+            if item_g is None:
                 return SymbolFailed
+
+            value = item_g.get(name_str, SymbolFailed)
             return value
 
 

pymathics/graph/generators.py

@@ -131,6 +131,17 @@ def graph_helper(
     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),
+}
+
+
+
 class BalancedTree(_NetworkXBuiltin):
     """
     <dl>
@@ -463,13 +474,47 @@ def eval(self, n, expression, evaluation: Evaluation, options: dict):
         return g
 
 
+class GraphData(_NetworkXBuiltin):
+    """
+    <dl>
+      <dt>'GraphData[$name$]'
+      <dd>Returns a graph with the specified name.
+    </dl>
+
+    >> GraphData["PappusGraph"]
+     = -Graph-
+    """
+    
+    def eval(self, name, expression, evaluation: Evaluation, options: dict) -> Graph:
+        "Pymathics`GraphData[name_String, OptionsPattern[%(name)s]]"
+        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
+
+    
 class HknHararyGraph(_NetworkXBuiltin):
-    """<dl>
-        <dt>'HmnHararyGraph[$k$, $n$]'
-        <dd>Returns the Harary graph with given node connectivity and node number.
+    """
+    <dl>
+      <dt>'HmnHararyGraph[$k$, $n$]'
+      <dd>Returns the Harary graph with given node connectivity and node number.
 
-      This second generator gives the Harary graph that minimizes the
-      number of edges in the graph with given node connectivity and
+      This second generator gives the Harary graph that minimizes the \
+      number of edges in the graph with given node connectivity and   \
       number of nodes.
 
       Harary, F.  The Maximum Connectivity of a Graph.  Proc. Nat. Acad. Sci. USA 48, 1142-1146, 1962.
@@ -495,8 +540,8 @@ class HmnHararyGraph(_NetworkXBuiltin):
       <dt>'HmnHararyGraph[$m$, $n$]'
       <dd>Returns the Harary graph with given numbers of nodes and edges.
 
-      This generator gives the Harary graph that maximizes the node
-      connectivity with given number of nodes and given number of
+      This generator gives the Harary graph that maximizes the node \
+      connectivity with given number of nodes and given number of \
       edges.
 
       Harary, F.  The Maximum Connectivity of a Graph.  Proc. Nat. Acad. Sci. USA 48, 1142-1146, 1962.
@@ -740,43 +785,3 @@ def eval(
         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),
-}
-
-
-class GraphData(_NetworkXBuiltin):
-    """
-    <dl>
-      <dt>'GraphData[$name$]'
-      <dd>Returns a graph with the specified name.
-    </dl>
-
-    >> GraphData["PappusGraph"]
-     = -Graph-
-    """
-
-    def eval(self, name, expression, evaluation: Evaluation, options: dict) -> Graph:
-        "%(name)s[name_String, OptionsPattern[%(name)s]]"
-        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

test/helper.py

@@ -4,12 +4,10 @@
 
 from mathics.session import MathicsSession
 
-session = MathicsSession(add_builtin=True, catch_interrupt=False)
-
-# Set up a Mathics3 session with definitions.
+# Set up a Mathics session with definitions.
 # For consistency set the character encoding ASCII which is
 # the lowest common denominator available on all systems.
-session = MathicsSession(character_encoding="ASCII")
+session = MathicsSession(add_builtin=True, catch_interrupt=False, character_encoding="ASCII")
 
 
 def reset_session(add_builtin=True, catch_interrupt=False):