Style on tree; add 1st tree pytest

Author: rocky

pymathics/graph/__main__.py

@@ -14,9 +14,9 @@
 
 from mathics.builtin.base import AtomBuiltin, Builtin
 from mathics.builtin.box.graphics import GraphicsBox
-from mathics.core.atoms import Integer, Integer0, Integer1, Real
+from mathics.core.atoms import Atom, Integer, Integer0, Integer1, Real
 from mathics.core.convert.expression import ListExpression, from_python
-from mathics.core.expression import Atom, Expression
+from mathics.core.expression import Expression
 from mathics.core.symbols import Symbol, SymbolFalse, SymbolTrue
 from mathics.core.systemsymbols import (
     SymbolBlank,

pymathics/graph/tree.py

@@ -1,5 +1,7 @@
 import networkx as nx
-from mathics.core.expression import Atom, Symbol
+from mathics.core.atoms import Atom
+from mathics.core.evaluation import Evaluation
+from mathics.core.symbols import SymbolConstant, SymbolFalse, SymbolTrue
 
 from pymathics.graph.__main__ import (
     DEFAULT_GRAPH_OPTIONS,
@@ -16,37 +18,43 @@
 from mathics.builtin.base import AtomBuiltin
 
 
-class TreeGraphAtom(AtomBuiltin):
+def eval_TreeGraphQ(g: Graph) -> SymbolConstant:
     """
-    >> TreeGraph[{1->2, 2->3, 3->1}]
-     = -Graph-
-
+    Returns SymbolTrue if g is a (networkx) tree and SymbolFalse
+    otherwise.
     """
+    if not isinstance(g, Graph):
+        return SymbolFalse
+    return SymbolTrue if nx.is_tree(g.G) else SymbolFalse
 
+
+# FIXME: do we need to have TreeGraphAtom and TreeGraph?
+# Can't these be combined into one?
+class TreeGraphAtom(AtomBuiltin):
     options = DEFAULT_TREE_OPTIONS
 
     messages = {
         "v": "Expected first parameter vertices to be a list of vertices",
         "notree": "Graph is not a tree.",
     }
 
-    def eval(self, rules, evaluation, options):
+    def eval(self, rules, evaluation: Evaluation, options: dict):
         "TreeGraph[rules_List, OptionsPattern[%(name)s]]"
-        g = _graph_from_list(rules.leaves, options)
+        g = _graph_from_list(rules.elements, options)
         if not nx.is_tree(g.G):
             evaluation.message(self.get_name(), "notree")
 
         g.G.graph_layout = "tree"
         # Compute/check/set for root?
         return g
 
-    def eval_with_v_e(self, vertices, edges, evaluation, options):
+    def eval_with_v_e(self, vertices, edges, evaluation: Evaluation, options: dict):
         "TreeGraph[vertices_List, edges_List, OptionsPattern[%(name)s]]"
-        if not all(isinstance(v, Atom) for v in vertices.leaves):
+        if not all(isinstance(v, Atom) for v in vertices.elements):
             evaluation.message(self.get_name(), "v")
 
         g = _graph_from_list(
-            edges.leaves, options=options, new_vertices=vertices.leaves
+            edges.elements, options=options, new_vertices=vertices.elements
         )
         if not nx.is_tree(g.G):
             evaluation.message(self.get_name(), "notree")
@@ -57,6 +65,12 @@ def eval_with_v_e(self, vertices, edges, evaluation, options):
 
 
 class TreeGraph(Graph):
+    """
+    >> TreeGraph[{1->2, 2->3, 2->4}]
+     = -Graph-
+
+    """
+
     options = DEFAULT_TREE_OPTIONS
 
     messages = {
@@ -85,8 +99,8 @@ class TreeGraphQ(_NetworkXBuiltin):
      = False
     """
 
-    def eval(self, g, expression, evaluation, options):
+    def eval(
+        self, g, expression, evaluation: Evaluation, options: dict
+    ) -> SymbolConstant:
         "TreeGraphQ[g_, OptionsPattern[%(name)s]]"
-        if not isinstance(g, Graph):
-            return Symbol("False")
-        return Symbol("True" if nx.is_tree(g.G) else "False")
+        return eval_TreeGraphQ(g)

test/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

test/helper.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+import time
+from typing import Optional
+
+from mathics.session import MathicsSession
+
+# 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")
+
+
+def reset_session(add_builtin=True, catch_interrupt=False):
+    global session
+    session.reset()
+
+
+def evaluate_value(str_expr: str):
+    return session.evaluate(str_expr).value
+
+
+def evaluate(str_expr: str):
+    return session.evaluate(str_expr)
+
+
+def check_evaluation(
+    str_expr: str,
+    str_expected: str,
+    failure_message: str = "",
+    hold_expected: bool = False,
+    to_string_expr: bool = True,
+    to_string_expected: bool = True,
+    to_python_expected: bool = False,
+    expected_messages: Optional[tuple] = None,
+):
+    """
+    Helper function to test Mathics expression against
+    its results
+
+    Compares the expressions represented by ``str_expr`` and  ``str_expected`` by evaluating
+    the first, and optionally, the second.
+
+    to_string_expr: If ``True`` (default value) the result of the evaluation is converted
+                    into a Python string. Otherwise, the expression is kept as an Expression
+                    object. If this argument is set to ``None``, the session is reset.
+
+    failure_message (str): message shown in case of failure
+    hold_expected (bool): If ``False`` (default value) the ``str_expected`` is evaluated. Otherwise,
+                          the expression is considered literally.
+
+    to_string_expected: If ``True`` (default value) the expected expression is
+                    evaluated and then converted to a Python string. result of the evaluation is converted
+                    into a Python string. If ``False``, the expected expression is kept as an Expression object.
+
+    to_python_expected: If ``True``, and ``to_string_expected`` is ``False``, the result of evaluating ``str_expr``
+                    is compared against the result of the evaluation of ``str_expected``, converted into a
+                    Python object.
+
+    expected_messages ``Optional[tuple[str]]``: If a tuple of strings are passed into this parameter, messages and prints raised during
+                    the evaluation of ``str_expr`` are compared with the elements of the list. If ``None``, this comparison
+                    is ommited.
+    """
+    if str_expr is None:
+        reset_session()
+        return
+
+    if to_string_expr:
+        str_expr = f"ToString[{str_expr}]"
+        result = evaluate_value(str_expr)
+    else:
+        result = evaluate(str_expr)
+
+    outs = [out.text for out in session.evaluation.out]
+
+    if to_string_expected:
+        if hold_expected:
+            expected = str_expected
+        else:
+            str_expected = f"ToString[{str_expected}]"
+            expected = evaluate_value(str_expected)
+    else:
+        if hold_expected:
+            if to_python_expected:
+                expected = str_expected
+            else:
+                expected = evaluate(f"HoldForm[{str_expected}]").elements[0]
+        else:
+            expected = evaluate(str_expected)
+            if to_python_expected:
+                expected = expected.to_python(string_quotes=False)
+
+    print(time.asctime())
+    if failure_message:
+        print((result, expected))
+        assert result == expected, failure_message
+    else:
+        print((result, expected))
+        assert result == expected
+
+    if expected_messages is not None:
+        msgs = list(expected_messages)
+        expected_len = len(msgs)
+        got_len = len(outs)
+        assert (
+            expected_len == got_len
+        ), f"expected {expected_len}; got {got_len}. Messages: {outs}"
+        for (out, msg) in zip(outs, msgs):
+            if out != msg:
+                print(f"out:<<{out}>>")
+                print(" and ")
+                print(f"expected=<<{msg}>>")
+                assert False, " do not match."

test/test_algorithms.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-Unit tests for mathics.builtins.numbers.algebra
+Unit tests for pymathics.graph.algorithms
 """
 from test.helper import check_evaluation, evaluate, evaluate_value
 

test/test_tree.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for pymathics.graph.tree
+"""
+from test.helper import check_evaluation, evaluate_value
+
+
+def setup_module(module):
+    """Load pymathics.graph"""
+    assert evaluate_value('LoadModule["pymathics.graph"]') == "pymathics.graph"
+
+
+def test_tree():
+    for str_expr, str_expected in [
+        ("TreeGraphQ[StarGraph[3]]", "True"),
+        ("TreeGraphQ[CompleteGraph[0]]", "False"),
+        ("TreeGraphQ[CompleteGraph[1]]", "True"),
+        ("TreeGraphQ[CompleteGraph[2]]", "True"),
+        ("TreeGraphQ[CompleteGraph[3]]", "False"),
+    ]:
+        check_evaluation(str_expr, str_expected)