ripple-down-rules 0.6.18__tar.gz → 0.6.20__tar.gz

{ripple_down_rules-0.6.18 → ripple_down_rules-0.6.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.18
+Version: 0.6.20
 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.18 → ripple_down_rules-0.6.20}/src/ripple_down_rules/__init__.py

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

{ripple_down_rules-0.6.18 → ripple_down_rules-0.6.20}/src/ripple_down_rules/rdr_decorators.py

@@ -34,7 +34,8 @@ class RDRDecorator:
                  package_name: Optional[str] = None,
                  use_generated_classifier: bool = False,
                  ask_now: Callable[Dict[str, Any], bool] = lambda _: True,
-                 fitting_decorator: Optional[Callable] = None):
+                 fitting_decorator: Optional[Callable] = None,
+                 generate_dot_file: bool = False) -> None:
         """
         :param models_dir: The directory to save/load the RDR models.
         :param output_type: The type of the output. This is used to create the RDR model.
@@ -51,6 +52,10 @@ class RDRDecorator:
         :param viewer: The viewer to use for the RDR model. If None, no viewer will be used.
         :param package_name: The package name to use for relative imports in the RDR model.
         :param use_generated_classifier: If True, the function will use the generated classifier instead of the RDR model.
+        :param ask_now: A callable that takes the case dictionary and returns True if the user should be asked for
+            the output, or False if the function should return the output without asking.
+        :param fitting_decorator: A decorator to use for the fitting function. If None, no decorator will be used.
+        :param generate_dot_file: If True, the RDR model will generate a dot file for visualization.
         :return: A decorator to use a GeneralRDR as a classifier that monitors and modifies the function's output.
         """
         self.rdr_models_dir = models_dir
@@ -69,6 +74,7 @@ class RDRDecorator:
         self.ask_now = ask_now
         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.load()
 
     def decorator(self, func: Callable) -> Callable:
@@ -110,6 +116,8 @@ class RDRDecorator:
                     output = self.generated_classifier(case)
                 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}')
 
             if self.output_name in output:
                 return output[self.output_name]

{ripple_down_rules-0.6.18 → ripple_down_rules-0.6.20}/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):
@@ -1653,12 +1849,68 @@ 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)
 
+    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,
                 filename: str = "scrdr", only_nodes: List[Node] = None):

{ripple_down_rules-0.6.18 → ripple_down_rules-0.6.20}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.18
+Version: 0.6.20
 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