ripple-down-rules 0.6.1__py3-none-any.whl → 0.6.6__py3-none-any.whl

ripple_down_rules/utils.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import ast
 import builtins
+import codecs
 import copyreg
 import importlib
 import json
-import logging
 import os
 import re
+import shutil
 import sys
 import threading
 import uuid
@@ -17,36 +17,41 @@ 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
+from types import NoneType, ModuleType
+import inspect
 
+import six
+from graphviz import Source
 from sqlalchemy.exc import NoInspectionAvailable
-
+from . import logger
 
 try:
     import matplotlib
     from matplotlib import pyplot as plt
+
     Figure = plt.Figure
 except ImportError as e:
     matplotlib = None
     plt = None
     Figure = None
-    logging.debug(f"{e}: matplotlib is not installed")
+    logger.debug(f"{e}: matplotlib is not installed")
 
 try:
     import networkx as nx
 except ImportError as e:
     nx = None
-    logging.debug(f"{e}: networkx is not installed")
+    logger.debug(f"{e}: networkx is not installed")
 
 import requests
-from anytree import Node, RenderTree
-from anytree.exporter import DotExporter
-from sqlalchemy import MetaData, inspect
+from anytree import Node, RenderTree, PreOrderIter
+from sqlalchemy import MetaData, inspect as sql_inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
 from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get_type_hints, \
-    get_origin, get_args, Tuple, Optional, List, Union, Self, ForwardRef, Sequence, Iterable
+    get_origin, get_args, Tuple, Optional, List, Union, Self, ForwardRef, Iterable
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -55,6 +60,49 @@ if TYPE_CHECKING:
 import ast
 
 
+def get_and_import_python_modules_in_a_package(file_paths: List[str],
+                                               parent_package_name: Optional[str] = None) -> List[Optional[ModuleType]]:
+    """
+    :param file_paths: The paths to the python files to import.
+    :param parent_package_name: The name of the parent package to use for relative imports.
+    :return: The imported modules.
+    """
+    package_path = dirname(file_paths[0])
+    package_import_path = get_import_path_from_path(package_path)
+    file_names = [Path(file_path).name.replace(".py", "") for file_path in file_paths]
+    module_import_paths = [
+        f"{package_import_path}.{file_name}" if package_import_path else file_name
+        for file_name in file_names
+    ]
+    modules = [
+        importlib.import_module(module_import_path, package=parent_package_name)
+        if os.path.exists(file_paths[i]) else None
+        for i, module_import_path in enumerate(module_import_paths)
+    ]
+    for module in modules:
+        if module is not None:
+            importlib.reload(module)
+    return modules
+
+
+def get_and_import_python_module(python_file_path: str, package_import_path: Optional[str] = None,
+                                 parent_package_name: Optional[str] = None) -> ModuleType:
+    """
+    :param python_file_path: The path to the python file to import.
+    :param package_import_path: The import path of the package that contains the python file.
+    :param parent_package_name: The name of the parent package to use for relative imports.
+    :return: The imported module.
+    """
+    if package_import_path is None:
+        package_path = dirname(python_file_path)
+        package_import_path = get_import_path_from_path(package_path)
+    file_name = Path(python_file_path).name.replace(".py", "")
+    module_import_path = f"{package_import_path}.{file_name}" if package_import_path else file_name
+    module = importlib.import_module(module_import_path, package=parent_package_name)
+    importlib.reload(module)
+    return module
+
+
 def str_to_snake_case(snake_str: str) -> str:
     """
     Convert a string to snake case.
@@ -120,22 +168,30 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
                 try:
                     scope[asname] = importlib.import_module(module_name, package=package_name)
                 except ImportError as e:
-                    print(f"Could not import {module_name}: {e}")
+                    logger.warning(f"Could not import {module_name}: {e}")
         elif isinstance(node, ast.ImportFrom):
             module_name = node.module
             for alias in node.names:
                 name = alias.name
                 asname = alias.asname or name
                 try:
-                    if package_name is not None and node.level > 0: # Handle relative imports
+                    if node.level > 0:  # Handle relative imports
+                        package_name = get_import_path_from_path(Path(os.path.join(file_path, *['..'] * node.level)).resolve())
+                    if package_name is not None and node.level > 0:  # Handle relative imports
                         module_rel_path = Path(os.path.join(file_path, *['..'] * node.level, module_name)).resolve()
                         idx = str(module_rel_path).rfind(package_name)
                         if idx != -1:
                             module_name = str(module_rel_path)[idx:].replace(os.path.sep, '.')
-                    module = importlib.import_module(module_name, package=package_name)
-                    scope[asname] = getattr(module, name)
+                    try:
+                        module = importlib.import_module(module_name, package=package_name)
+                    except ModuleNotFoundError:
+                        module = importlib.import_module(f"{package_name}.{module_name}")
+                    if name == "*":
+                        scope.update(module.__dict__)
+                    else:
+                        scope[asname] = getattr(module, name)
                 except (ImportError, AttributeError) as e:
-                    logging.warning(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
+                    logger.warning(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
 
     return scope
 
@@ -143,7 +199,9 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
 def extract_function_source(file_path: str,
                             function_names: List[str], join_lines: bool = True,
                             return_line_numbers: bool = False,
-                            include_signature: bool = True) \
+                            include_signature: bool = True,
+                            as_list: bool = False,
+                            is_class: bool = False) \
         -> Union[Dict[str, Union[str, List[str]]],
         Tuple[Dict[str, Union[str, List[str]]], Dict[str, Tuple[int, int]]]]:
     """
@@ -154,6 +212,9 @@ def extract_function_source(file_path: str,
     :param join_lines: Whether to join the lines of the function.
     :param return_line_numbers: Whether to return the line numbers of the function.
     :param include_signature: Whether to include the function signature in the source code.
+    :param as_list: Whether to return a list of function sources instead of dict (useful when there is multiple
+     functions with same name).
+    :param is_class: Whether to also look for class definitions
     :return: A dictionary mapping function names to their source code as a string if join_lines is True,
      otherwise as a list of strings.
     """
@@ -164,24 +225,39 @@ def extract_function_source(file_path: str,
     tree = ast.parse(source)
     function_names = make_list(function_names)
     functions_source: Dict[str, Union[str, List[str]]] = {}
+    functions_source_list: List[Union[str, List[str]]] = []
     line_numbers: Dict[str, Tuple[int, int]] = {}
+    line_numbers_list: List[Tuple[int, int]] = []
+    if is_class:
+        look_for_type = ast.ClassDef
+    else:
+        look_for_type = ast.FunctionDef
+
     for node in tree.body:
-        if isinstance(node, ast.FunctionDef) and (node.name in function_names or len(function_names) == 0):
+        if isinstance(node, look_for_type) and (node.name in function_names or len(function_names) == 0):
             # Get the line numbers of the function
             lines = source.splitlines()
             func_lines = lines[node.lineno - 1:node.end_lineno]
             if not include_signature:
                 func_lines = func_lines[1:]
-            line_numbers[node.name] = (node.lineno, node.end_lineno)
-            functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
-            if (len(functions_source) >= len(function_names)) and (not len(function_names) == 0):
-                break
-    if len(functions_source) < len(function_names):
-        raise ValueError(f"Could not find all functions in {file_path}: {function_names} not found,"
-                         f"functions not found: {set(function_names) - set(functions_source.keys())}")
+            if as_list:
+                line_numbers_list.append((node.lineno, node.end_lineno))
+            else:
+                line_numbers[node.name] = (node.lineno, node.end_lineno)
+            parsed_function = dedent("\n".join(func_lines)) if join_lines else func_lines
+            if as_list:
+                functions_source_list.append(parsed_function)
+            else:
+                functions_source[node.name] = parsed_function
+            if len(function_names) > 0:
+                if len(functions_source) >= len(function_names) or len(functions_source_list) >= len(function_names):
+                    break
+    if len(functions_source) < len(function_names) and len(functions_source_list) < len(function_names):
+        logger.warning(f"Could not find all functions in {file_path}: {function_names} not found, "
+                f"functions not found: {set(function_names) - set(functions_source.keys())}")
     if return_line_numbers:
-        return functions_source, line_numbers
-    return functions_source
+        return functions_source if not as_list else functions_source_list, line_numbers if not as_list else line_numbers_list
+    return functions_source if not as_list else functions_source_list
 
 
 def encapsulate_user_input(user_input: str, func_signature: str, func_doc: Optional[str] = None) -> str:
@@ -193,7 +269,8 @@ def encapsulate_user_input(user_input: str, func_signature: str, func_doc: Optio
     :param func_doc: The function docstring to use for encapsulation.
     :return: The encapsulated user input string.
     """
-    if func_signature not in user_input:
+    func_name = func_signature.split('(')[0].strip()
+    if func_name not in user_input:
         new_user_input = func_signature + "\n    "
         if func_doc is not None:
             new_user_input += f"\"\"\"{func_doc}\"\"\"" + "\n    "
@@ -282,7 +359,7 @@ def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
         case_query.case.update(conclusions)
 
 
-def is_conflicting(conclusion: Any, target: Any) -> bool:
+def is_value_conflicting(conclusion: Any, target: Any) -> bool:
     """
     :param conclusion: The conclusion to check.
     :param target: The target to compare the conclusion with.
@@ -621,18 +698,21 @@ def capture_variable_assignment(code: str, variable_name: str) -> Optional[str]:
     return assignment
 
 
-def get_func_rdr_model_path(func: Callable, model_dir: str) -> str:
+def get_func_rdr_model_path(func: Callable, model_dir: str, include_file_name: bool = False) -> str:
     """
     :param func: The function to get the model path for.
     :param model_dir: The directory to save the model to.
+    :param include_file_name: Whether to include the file name in the model name.
     :return: The path to the model file.
     """
-    return os.path.join(model_dir, f"{get_func_rdr_model_name(func)}.json")
+    return os.path.join(model_dir, get_func_rdr_model_name(func, include_file_name=include_file_name),
+                        f"{get_func_rdr_model_name(func)}_rdr.py")
 
 
 def get_func_rdr_model_name(func: Callable, include_file_name: bool = False) -> str:
     """
     :param func: The function to get the model name for.
+    :param include_file_name: Whether to include the file name in the model name.
     :return: The name of the model.
     """
     func_name = get_method_name(func)
@@ -644,7 +724,7 @@ def get_func_rdr_model_name(func: Callable, include_file_name: bool = False) ->
         model_name = ''
     model_name += f"{func_class_name}_" if func_class_name else ""
     model_name += f"{func_name}"
-    return model_name
+    return str_to_snake_case(model_name)
 
 
 def stringify_hint(tp):
@@ -681,6 +761,7 @@ def is_builtin_type(tp):
 def is_typing_type(tp):
     return tp.__module__ == "typing"
 
+
 origin_type_to_hint = {
     list: List,
     set: Set,
@@ -688,6 +769,47 @@ origin_type_to_hint = {
     tuple: Tuple,
 }
 
+
+def get_file_that_ends_with(directory_path: str, suffix: str) -> Optional[str]:
+    """
+    Get the file that ends with the given suffix in the model directory.
+
+    :param directory_path: The path to the directory where the file is located.
+    :param suffix: The suffix to search for.
+    :return: The path to the file that ends with the given suffix, or None if not found.
+    """
+    files = [f for f in os.listdir(directory_path) if f.endswith(suffix)]
+    if files:
+        return files[0]
+    return None
+
+def get_function_return_type(func: Callable) -> Union[Type, None, Tuple[Type, ...]]:
+    """
+    Get the return type of a function.
+
+    :param func: The function to get the return type for.
+    :return: The return type of the function, or None if not specified.
+    """
+    sig = inspect.signature(func)
+    if sig.return_annotation == inspect.Signature.empty:
+        return None
+    type_hint = sig.return_annotation
+    return get_type_from_type_hint(type_hint)
+
+
+def get_type_from_type_hint(type_hint: Type) -> Union[Type, Tuple[Type, ...]]:
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+    if origin not in [list, set, None, Union]:
+        raise TypeError(f"{origin} is not a handled return type for type hint {type_hint}")
+    if origin is None:
+        return typing_to_python_type(type_hint)
+    if args is None or len(args) == 0:
+        return typing_to_python_type(type_hint)
+    return args
+
+
+
 def extract_types(tp, seen: Set = None) -> Set[type]:
     """Recursively extract all base types from a type hint."""
     if seen is None:
@@ -786,6 +908,13 @@ def get_import_path_from_path(path: str) -> Optional[str]:
     return package_name
 
 
+def get_class_file_path(cls):
+    """
+    Get the file path of a class.
+    """
+    return os.path.abspath(inspect.getfile(cls))
+
+
 def get_function_import_data(func: Callable) -> Tuple[str, str]:
     """
     Get the import path of a function.
@@ -840,10 +969,12 @@ def get_relative_import(target_file_path, imported_module_path: Optional[str] =
     imported_file_name = Path(imported_module_path).name
     target_file_name = Path(target_file_path).name
     if package_name is not None:
-        target_path = Path(get_path_starting_from_latest_encounter_of(str(target_path), package_name, [target_file_name]))
+        target_path = Path(
+            get_path_starting_from_latest_encounter_of(str(target_path), package_name, [target_file_name]))
     imported_path = Path(imported_module_path).resolve()
     if package_name is not None:
-        imported_path = Path(get_path_starting_from_latest_encounter_of(str(imported_path), package_name, [imported_file_name]))
+        imported_path = Path(
+            get_path_starting_from_latest_encounter_of(str(imported_path), package_name, [imported_file_name]))
 
     # Compute relative path from target to imported module
     rel_path = os.path.relpath(imported_path.parent, target_path.parent)
@@ -920,8 +1051,8 @@ def get_imports_from_types(type_objs: Iterable[Type],
                 continue
             if name == "NoneType":
                 module = "types"
-            if module is None or module == 'builtins' or module.startswith('_')\
-                or module in sys.builtin_module_names or module in excluded_modules or "<" in module \
+            if module is None or module == 'builtins' or module.startswith('_') \
+                    or module in sys.builtin_module_names or module in excluded_modules or "<" in module \
                     or name in exclueded_names:
                 continue
             if module == "typing":
@@ -989,7 +1120,8 @@ def get_method_class_name_if_exists(method: Callable) -> Optional[str]:
             return method.__self__.__name__
         elif hasattr(method.__self__, "__class__"):
             return method.__self__.__class__.__name__
-    return method.__qualname__.split('.')[0] if hasattr(method, "__qualname__") else None
+    return (method.__qualname__.split('.')[0]
+            if hasattr(method, "__qualname__") and '.' in method.__qualname__ else None)
 
 
 def get_method_class_if_exists(method: Callable, *args) -> Optional[Type]:
@@ -1087,6 +1219,7 @@ def get_full_class_name(cls):
 def recursive_subclasses(cls):
     """
     Copied from: https://github.com/tomsch420/random-events/blob/master/src/random_events/utils.py#L6C1-L21C101
+
     :param cls: The class.
     :return: A list of the classes subclasses.
     """
@@ -1211,7 +1344,8 @@ class SubclassJSONSerializer:
             return cls._from_json(data)
         for subclass in recursive_subclasses(SubclassJSONSerializer):
             if get_full_class_name(subclass) == data["_type"]:
-                subclass_data = deepcopy(data)
+                # subclass_data = deepcopy(data)
+                subclass_data = data
                 subclass_data.pop("_type")
                 return subclass._from_json(subclass_data)
 
@@ -1273,7 +1407,7 @@ def copy_orm_instance(instance: SQLTable) -> SQLTable:
     :return: The copied instance.
     """
     try:
-        session: Session = inspect(instance).session
+        session: Session = sql_inspect(instance).session
     except NoInspectionAvailable:
         session = None
     if session is not None:
@@ -1284,7 +1418,7 @@ def copy_orm_instance(instance: SQLTable) -> SQLTable:
         try:
             new_instance = deepcopy(instance)
         except Exception as e:
-            logging.debug(e)
+            logger.debug(e)
             new_instance = instance
     return new_instance
 
@@ -1304,7 +1438,7 @@ def copy_orm_instance_with_relationships(instance: SQLTable) -> SQLTable:
             try:
                 setattr(instance_cp, rel.key, related_obj_cp)
             except Exception as e:
-                logging.debug(e)
+                logger.debug(e)
     return instance_cp
 
 
@@ -1400,9 +1534,14 @@ def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20
     keys_values = [list(r[0]) + list(r[1]) if len(r) > 1 else r[0] for r in keys_values]
     all_table_rows = []
     row_values = [list(map(lambda v: str(v) if v is not None else "", row)) for row in keys_values]
-    row_values = [list(map(lambda v: v[:max_line_sze] + '...' if len(v) > max_line_sze else v, row)) for row in row_values]
+    row_values = [list(map(lambda v: v[:max_line_sze] + '...' if len(v) > max_line_sze else v, row)) for row in
+                  row_values]
     row_values = [list(map(lambda v: v.lower() if v in ["True", "False"] else v, row)) for row in row_values]
-    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[max_line_sze] * 2)
+    # Step 1: Get terminal size
+    terminal_width = shutil.get_terminal_size((80, 20)).columns
+    # Step 2: Dynamically calculate max width per column (simple approximation)
+    max_col_width = terminal_width // len(row_values[0])
+    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=max_col_width)  # [max_line_sze] * 2)
     all_table_rows.append(table)
     return "\n".join(all_table_rows)
 
@@ -1551,6 +1690,13 @@ def get_all_subclasses(cls: Type) -> Dict[str, Type]:
     return all_subclasses
 
 
+def make_tuple(value: Any) -> Any:
+    """
+    Make a tuple from a value.
+    """
+    return tuple(value) if is_iterable(value) else (value,)
+
+
 def make_set(value: Any) -> Set:
     """
     Make a set from a value.
@@ -1622,34 +1768,358 @@ def edge_attr_setter(parent, child):
     """
     Set the edge attributes for the dot exporter.
     """
-    if child and hasattr(child, "weight") and child.weight:
+    if child and hasattr(child, "weight") and child.weight is not None:
         return f'style="bold", label=" {child.weight}"'
     return ""
 
 
+_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(node)
+        self.include_node_names = [node_name_func(n) for n in self.include_nodes] if include_nodes else None
+
+    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
+        legend_dot_graph = """
+// Color legend as a subgraph
+subgraph cluster_legend {
+    label = "Legend";
+    style = dashed;
+    color = gray;
+
+    legend_green [label="Fired->Query Related Value", shape=box, style=filled, fillcolor=green, fontcolor=black, size=0.5];
+    legend_yellow [label="Fired->Some Value", shape=box, style=filled, fillcolor=yellow, fontcolor=black, size=0.5];
+    legend_orange [label="Fired->Empty Value", shape=box, style=filled, fillcolor=orange, fontcolor=black, size=0.5];
+    legend_red [label="Evaluated->Not Fired", shape=box, style=filled, fillcolor=red, fontcolor=black, size=0.5];
+    legend_white [label="Not Evaluated",  shape=box, style=filled, fillcolor=white, fontcolor=black, size=0.5];
+
+    // Invisible edges to arrange legend vertically
+    legend_white -> legend_red -> legend_orange -> legend_yellow -> legend_green [style=invis];
+}"""
+        for line in legend_dot_graph.splitlines():
+            yield "%s" % (line.strip())
+        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):
+            nodename = nodenamefunc(node)
+            if self.include_nodes is not None and nodename not in self.include_node_names:
+                continue
+            nodeattr = nodeattrfunc(node)
+            nodeattr = " [%s]" % nodeattr if nodeattr is not None else ""
+            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
+        for node in PreOrderIter(self.node, maxlevel=maxlevel):
+            nodename = nodenamefunc(node)
+            if self.include_nodes is not None and nodename not in self.include_node_names:
+                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, 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
+            logger.warning(msg)
+
+    def to_source(self) -> Source:
+        """
+        Return the source code of the graph as a Source object.
+        """
+        return Source("\n".join(self), filename=self.name)
+
+    @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"):
+                filename: str = "scrdr", only_nodes: List[Node] = None, show_in_console: bool = False,
+                color_map: Optional[Callable[[Node], str]] = None,
+                view: bool = False) -> None:
     """
     Render the tree using the console and optionally export it to a dot file.
 
     :param root: The root node of the tree.
     :param use_dot_exporter: Whether to export the tree to a dot file.
     :param filename: The name of the file to export the tree to.
+    :param only_nodes: A list of nodes to include in the dot export.
+    :param show_in_console: Whether to print the tree to the console.
+    :param color_map: A function that returns a color for certain nodes.
+    :param view: Whether to view the dot file in a viewer.
     """
     if not root:
-        logging.warning("No rules to render")
+        logger.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__()}")
+    if show_in_console:
+        for pre, _, node in RenderTree(root):
+            if only_nodes is not None and node not in only_nodes:
+                continue
+            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 = DotExporter(root,
-                         nodenamefunc=unique_node_names,
-                         edgeattrfunc=edge_attr_setter
-                         )
-        de.to_dotfile(f"{filename}{'.dot'}")
-        de.to_picture(f"{filename}{'.png'}")
+        de = FilteredDotExporter(root,
+                                 include_nodes=only_nodes,
+                                 nodenamefunc=unique_node_names,
+                                 edgeattrfunc=edge_attr_setter,
+                                 nodeattrfunc=lambda node: f'style=filled,'
+                                                           f' fillcolor={color_map(node) if color_map else node.color}',
+                                 )
+        if view:
+            de.to_source().view()
+        else:
+            filename = filename or "rule_tree"
+            de.to_dotfile(f"{filename}{'.dot'}")
+            try:
+                de.to_picture(f"{filename}{'.svg'}")
+            except FileNotFoundError as e:
+                logger.warning(f"{e}")
 
 
 def draw_tree(root: Node, fig: Figure):
@@ -1698,3 +2168,17 @@ def encapsulate_code_lines_into_a_function(code_lines: List[str], function_name:
     if f"return {function_name}({args})" not in code:
         code = code.strip() + f"\nreturn {function_name}({args})"
     return code
+
+
+def get_method_object_from_pytest_request(request) -> Callable:
+    test_module = request.module.__name__  # e.g., "test_my_module"
+    test_class = request.cls.__name__ if request.cls else None  # if inside a class
+    test_name = request.node.name
+    func = importlib.import_module(test_module)
+    if test_class:
+        func = getattr(getattr(func, test_class), test_name)
+    else:
+        func = getattr(func, test_name)
+    return func
+
+