ripple-down-rules 0.6.19__tar.gz → 0.6.21__tar.gz

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.19
+Version: 0.6.21
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/scripts/live_dot_server.py

@@ -41,7 +41,7 @@ def generate_html(dot_output="graph.html"):
     }}
 
     fetchAndRender();
-    setInterval(fetchAndRender, 2000);  // Refresh every 2 seconds
+    setInterval(fetchAndRender, 50);  // Refresh every 2 seconds
   </script>
 </body>
 </html>"""
@@ -82,8 +82,4 @@ if __name__ == "__main__":
     dot_file = sys.argv[1]
     port = int(sys.argv[2]) if len(sys.argv) > 2 else 8000
 
-    if not os.path.exists(dot_file):
-        print(f"Error: File '{dot_file}' does not exist.")
-        sys.exit(1)
-
     serve_dot(dot_file, port)

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/src/ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.19"
+__version__ = "0.6.21"
 
 import logging
 logger = logging.Logger("rdr")

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/src/ripple_down_rules/rdr.py

@@ -110,7 +110,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
     def render_evaluated_rule_tree(self, filename: str) -> None:
         evaluated_rules = self.get_evaluated_rule_tree()
-        if len(evaluated_rules) > 0:
+        if evaluated_rules is not None and len(evaluated_rules) > 0:
             render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
                         only_nodes=evaluated_rules)
 
@@ -121,7 +121,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :return: The evaluated rule tree.
         """
         if self.start_rule is None:
-            raise ValueError("The start rule is not set. Please set the start rule before getting the evaluated rule tree.")
+            return
+            # raise ValueError("The start rule is not set. Please set the start rule before getting the evaluated rule tree.")
         evaluated_rule_tree = [r for r in [self.start_rule] + list(self.start_rule.descendants) if r.evaluated]
         return evaluated_rule_tree
 

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/src/ripple_down_rules/rdr_decorators.py

@@ -75,6 +75,7 @@ class RDRDecorator:
         self.fitting_decorator = fitting_decorator if fitting_decorator is not None else \
             lambda f: f  # Default to no fitting decorator
         self.generate_dot_file = generate_dot_file
+        self.not_none_output_found: bool = False
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
@@ -117,7 +118,11 @@ class RDRDecorator:
                 else:
                     output = self.rdr.classify(case)
                     if self.generate_dot_file:
-                        self.rdr.render_evaluated_rule_tree(self.rdr_models_dir + f'/{self.model_name}')
+                        eval_rule_tree = self.rdr.get_evaluated_rule_tree()
+                        if not self.not_none_output_found or (eval_rule_tree and len(eval_rule_tree) > 1):
+                            self.rdr.render_evaluated_rule_tree(self.rdr_models_dir + f'/{self.model_name}')
+                        if eval_rule_tree and len(eval_rule_tree) > 1:
+                            self.not_none_output_found = True
 
             if self.output_name in output:
                 return output[self.output_name]

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/src/ripple_down_rules/utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import builtins
+import codecs
 import copyreg
 import importlib
 import json
@@ -16,9 +17,12 @@ from dataclasses import is_dataclass, fields
 from enum import Enum
 from os.path import dirname
 from pathlib import Path
+from subprocess import check_call
+from tempfile import NamedTemporaryFile
 from textwrap import dedent
 from types import NoneType
 
+import six
 from sqlalchemy.exc import NoInspectionAvailable
 
 try:
@@ -1629,12 +1633,204 @@ def edge_attr_setter(parent, child):
     return ""
 
 
-class FilteredDotExporter(DotExporter):
-    def __init__(self, root, include_nodes=None, **kwargs):
+_RE_ESC = re.compile(r'["\\]')
+class FilteredDotExporter(object):
+
+    def __init__(self, node, include_nodes=None, graph="digraph", name="tree", options=None,
+                 indent=4, nodenamefunc=None, nodeattrfunc=None,
+                 edgeattrfunc=None, edgetypefunc=None, maxlevel=None):
+        """
+        Dot Language Exporter.
+
+        Args:
+            node (Node): start node.
+
+        Keyword Args:
+            graph: DOT graph type.
+
+            name: DOT graph name.
+
+            options: list of options added to the graph.
+
+            indent (int): number of spaces for indent.
+
+            nodenamefunc: Function to extract node name from `node` object.
+                          The function shall accept one `node` object as
+                          argument and return the name of it.
+
+            nodeattrfunc: Function to decorate a node with attributes.
+                          The function shall accept one `node` object as
+                          argument and return the attributes.
+
+            edgeattrfunc: Function to decorate a edge with attributes.
+                          The function shall accept two `node` objects as
+                          argument. The first the node and the second the child
+                          and return the attributes.
+
+            edgetypefunc: Function to which gives the edge type.
+                          The function shall accept two `node` objects as
+                          argument. The first the node and the second the child
+                          and return the edge (i.e. '->').
+
+            maxlevel (int): Limit export to this number of levels.
+
+        >>> from anytree import Node
+        >>> root = Node("root")
+        >>> s0 = Node("sub0", parent=root, edge=2)
+        >>> s0b = Node("sub0B", parent=s0, foo=4, edge=109)
+        >>> s0a = Node("sub0A", parent=s0, edge="")
+        >>> s1 = Node("sub1", parent=root, edge="")
+        >>> s1a = Node("sub1A", parent=s1, edge=7)
+        >>> s1b = Node("sub1B", parent=s1, edge=8)
+        >>> s1c = Node("sub1C", parent=s1, edge=22)
+        >>> s1ca = Node("sub1Ca", parent=s1c, edge=42)
+
+        .. note:: If the node names are not unqiue, see :any:`UniqueDotExporter`.
+
+        A directed graph:
+
+        >>> from anytree.exporter import DotExporter
+        >>> for line in DotExporter(root):
+        ...     print(line)
+        digraph tree {
+            "root";
+            "sub0";
+            "sub0B";
+            "sub0A";
+            "sub1";
+            "sub1A";
+            "sub1B";
+            "sub1C";
+            "sub1Ca";
+            "root" -> "sub0";
+            "root" -> "sub1";
+            "sub0" -> "sub0B";
+            "sub0" -> "sub0A";
+            "sub1" -> "sub1A";
+            "sub1" -> "sub1B";
+            "sub1" -> "sub1C";
+            "sub1C" -> "sub1Ca";
+        }
+
+        The resulting graph:
+
+        .. image:: ../static/dotexporter0.png
+
+        An undirected graph:
+
+        >>> def nodenamefunc(node):
+        ...     return '%s:%s' % (node.name, node.depth)
+        >>> def edgeattrfunc(node, child):
+        ...     return 'label="%s:%s"' % (node.name, child.name)
+        >>> def edgetypefunc(node, child):
+        ...     return '--'
+                >>> from anytree.exporter import DotExporter
+        >>> for line in DotExporter(root, graph="graph",
+        ...                             nodenamefunc=nodenamefunc,
+        ...                             nodeattrfunc=lambda node: "shape=box",
+        ...                             edgeattrfunc=edgeattrfunc,
+        ...                             edgetypefunc=edgetypefunc):
+        ...     print(line)
+        graph tree {
+            "root:0" [shape=box];
+            "sub0:1" [shape=box];
+            "sub0B:2" [shape=box];
+            "sub0A:2" [shape=box];
+            "sub1:1" [shape=box];
+            "sub1A:2" [shape=box];
+            "sub1B:2" [shape=box];
+            "sub1C:2" [shape=box];
+            "sub1Ca:3" [shape=box];
+            "root:0" -- "sub0:1" [label="root:sub0"];
+            "root:0" -- "sub1:1" [label="root:sub1"];
+            "sub0:1" -- "sub0B:2" [label="sub0:sub0B"];
+            "sub0:1" -- "sub0A:2" [label="sub0:sub0A"];
+            "sub1:1" -- "sub1A:2" [label="sub1:sub1A"];
+            "sub1:1" -- "sub1B:2" [label="sub1:sub1B"];
+            "sub1:1" -- "sub1C:2" [label="sub1:sub1C"];
+            "sub1C:2" -- "sub1Ca:3" [label="sub1C:sub1Ca"];
+        }
+
+        The resulting graph:
+
+        .. image:: ../static/dotexporter1.png
+
+        To export custom node implementations or :any:`AnyNode`, please provide a proper `nodenamefunc`:
+
+        >>> from anytree import AnyNode
+        >>> root = AnyNode(id="root")
+        >>> s0 = AnyNode(id="sub0", parent=root)
+        >>> s0b = AnyNode(id="s0b", parent=s0)
+        >>> s0a = AnyNode(id="s0a", parent=s0)
+
+        >>> from anytree.exporter import DotExporter
+        >>> for line in DotExporter(root, nodenamefunc=lambda n: n.id):
+        ...     print(line)
+        digraph tree {
+            "root";
+            "sub0";
+            "s0b";
+            "s0a";
+            "root" -> "sub0";
+            "sub0" -> "s0b";
+            "sub0" -> "s0a";
+        }
+        """
+        self.node = node
+        self.graph = graph
+        self.name = name
+        self.options = options
+        self.indent = indent
+        self.nodenamefunc = nodenamefunc
+        self.nodeattrfunc = nodeattrfunc
+        self.edgeattrfunc = edgeattrfunc
+        self.edgetypefunc = edgetypefunc
+        self.maxlevel = maxlevel
         self.include_nodes = include_nodes
-        node_name_func = get_unique_node_names_func(root)
+        node_name_func = get_unique_node_names_func(node)
         self.include_node_names = [node_name_func(n) for n in self.include_nodes] if include_nodes else None
-        super().__init__(root, **kwargs)
+
+    def __iter__(self):
+        # prepare
+        indent = " " * self.indent
+        nodenamefunc = self.nodenamefunc or self._default_nodenamefunc
+        nodeattrfunc = self.nodeattrfunc or self._default_nodeattrfunc
+        edgeattrfunc = self.edgeattrfunc or self._default_edgeattrfunc
+        edgetypefunc = self.edgetypefunc or self._default_edgetypefunc
+        return self.__iter(indent, nodenamefunc, nodeattrfunc, edgeattrfunc,
+                           edgetypefunc)
+
+    @staticmethod
+    def _default_nodenamefunc(node):
+        return node.name
+
+    @staticmethod
+    def _default_nodeattrfunc(node):
+        return None
+
+    @staticmethod
+    def _default_edgeattrfunc(node, child):
+        return None
+
+    @staticmethod
+    def _default_edgetypefunc(node, child):
+        return "->"
+
+    def __iter(self, indent, nodenamefunc, nodeattrfunc, edgeattrfunc, edgetypefunc):
+        yield "{self.graph} {self.name} {{".format(self=self)
+        for option in self.__iter_options(indent):
+            yield option
+        for node in self.__iter_nodes(indent, nodenamefunc, nodeattrfunc):
+            yield node
+        for edge in self.__iter_edges(indent, nodenamefunc, edgeattrfunc, edgetypefunc):
+            yield edge
+        yield "}"
+
+    def __iter_options(self, indent):
+        options = self.options
+        if options:
+            for option in options:
+                yield "%s%s" % (indent, option)
 
     def __iter_nodes(self, indent, nodenamefunc, nodeattrfunc):
         for node in PreOrderIter(self.node, maxlevel=self.maxlevel):
@@ -1643,7 +1839,7 @@ class FilteredDotExporter(DotExporter):
                 continue
             nodeattr = nodeattrfunc(node)
             nodeattr = " [%s]" % nodeattr if nodeattr is not None else ""
-            yield '%s"%s"%s;' % (indent, DotExporter.esc(nodename), nodeattr)
+            yield '%s"%s"%s;' % (indent, FilteredDotExporter.esc(nodename), nodeattr)
 
     def __iter_edges(self, indent, nodenamefunc, edgeattrfunc, edgetypefunc):
         maxlevel = self.maxlevel - 1 if self.maxlevel else None
@@ -1653,11 +1849,67 @@ class FilteredDotExporter(DotExporter):
                 continue
             for child in node.children:
                 childname = nodenamefunc(child)
+                if self.include_nodes is not None and childname not in self.include_node_names:
+                    continue
                 edgeattr = edgeattrfunc(node, child)
                 edgetype = edgetypefunc(node, child)
                 edgeattr = " [%s]" % edgeattr if edgeattr is not None else ""
-                yield '%s"%s" %s "%s"%s;' % (indent, DotExporter.esc(nodename), edgetype,
-                                             DotExporter.esc(childname), edgeattr)
+                yield '%s"%s" %s "%s"%s;' % (indent, FilteredDotExporter.esc(nodename), edgetype,
+                                             FilteredDotExporter.esc(childname), edgeattr)
+
+    def to_dotfile(self, filename):
+        """
+        Write graph to `filename`.
+
+        >>> from anytree import Node
+        >>> root = Node("root")
+        >>> s0 = Node("sub0", parent=root)
+        >>> s0b = Node("sub0B", parent=s0)
+        >>> s0a = Node("sub0A", parent=s0)
+        >>> s1 = Node("sub1", parent=root)
+        >>> s1a = Node("sub1A", parent=s1)
+        >>> s1b = Node("sub1B", parent=s1)
+        >>> s1c = Node("sub1C", parent=s1)
+        >>> s1ca = Node("sub1Ca", parent=s1c)
+
+        >>> from anytree.exporter import DotExporter
+        >>> DotExporter(root).to_dotfile("tree.dot")
+
+        The generated file should be handed over to the `dot` tool from the
+        http://www.graphviz.org/ package::
+
+            $ dot tree.dot -T png -o tree.png
+        """
+        with codecs.open(filename, "w", "utf-8") as file:
+            for line in self:
+                file.write("%s\n" % line)
+
+    def to_picture(self, filename):
+        """
+        Write graph to a temporary file and invoke `dot`.
+
+        The output file type is automatically detected from the file suffix.
+
+        *`graphviz` needs to be installed, before usage of this method.*
+        """
+        fileformat = os.path.splitext(filename)[1][1:]
+        with NamedTemporaryFile("wb", delete=False) as dotfile:
+            dotfilename = dotfile.name
+            for line in self:
+                dotfile.write(("%s\n" % line).encode("utf-8"))
+            dotfile.flush()
+            cmd = ["dot", dotfilename, "-T", fileformat, "-o", filename]
+            check_call(cmd)
+        try:
+            os.remove(dotfilename)
+        except Exception:  # pragma: no cover
+            msg = 'Could not remove temporary file %s' % dotfilename
+            logging.getLogger(__name__).warn(msg)
+
+    @staticmethod
+    def esc(value):
+        """Escape Strings."""
+        return _RE_ESC.sub(lambda m: r"\%s" % m.group(0), six.text_type(value))
 
 
 def render_tree(root: Node, use_dot_exporter: bool = False,
@@ -1673,18 +1925,19 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
     if not root:
         logging.warning("No rules to render")
         return
-    for pre, _, node in RenderTree(root):
-        print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
+    # for pre, _, node in RenderTree(root):
+    #     print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
     if use_dot_exporter:
         unique_node_names = get_unique_node_names_func(root)
 
         de = FilteredDotExporter(root,
                                  include_nodes=only_nodes,
                                  nodenamefunc=unique_node_names,
-                                 edgeattrfunc=edge_attr_setter
+                                 edgeattrfunc=edge_attr_setter,
+                                 nodeattrfunc=lambda node: f'style=filled, fillcolor={"green" if node.fired else "red"}'
                                  )
         de.to_dotfile(f"{filename}{'.dot'}")
-        de.to_picture(f"{filename}{'.png'}")
+        # de.to_picture(f"{filename}{'.png'}")
 
 
 def draw_tree(root: Node, fig: Figure):

{ripple_down_rules-0.6.19 → ripple_down_rules-0.6.21}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.19
+Version: 0.6.21
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE