Extended rule depenendency graph eval script class.

* added CLI support
* add rule string to GraphML export as separate attribute

Author: LorenzBuehmann

sansa-inference-common/pom.xml

@@ -83,6 +83,11 @@
       <version>3.5.0</version>
     </dependency>
 
+    <!-- Scopt CLI API-->
+    <dependency>
+      <groupId>com.github.scopt</groupId>
+      <artifactId>scopt_${scala.binary.version}</artifactId>
+    </dependency>
 
     <!-- Test -->
     <dependency>

sansa-inference-common/src/main/scala/net/sansa_stack/inference/utils/GraphUtils.scala

@@ -1,8 +1,8 @@
 package net.sansa_stack.inference.utils
 
 import java.io.{ByteArrayOutputStream, File, FileOutputStream, FileWriter}
+import java.util
 
-import scalax.collection.edge.LDiEdge
 import com.itextpdf.text.PageSize
 import org.apache.jena.graph.Node
 import org.apache.jena.reasoner.TriplePattern
@@ -19,13 +19,15 @@ import org.gephi.layout.plugin.force.yifanHu.YifanHuLayout
 import org.gephi.preview.api.{Item, PreviewController, PreviewProperty}
 import org.gephi.preview.types.EdgeColor
 import org.gephi.project.api.ProjectController
-import org.jgrapht.{DirectedGraph, Graph}
+import org.jgrapht.Graph
 import org.jgrapht.alg.isomorphism.VF2GraphIsomorphismInspector
+import org.jgrapht.graph.{DefaultDirectedGraph, DirectedPseudograph}
+import org.jgrapht.io.GraphMLExporter.AttributeCategory
+import org.jgrapht.io._
 import org.openide.util.Lookup
+import scalax.collection.edge.LDiEdge
 
-import net.sansa_stack.inference.utils.graph.{EdgeEquivalenceComparator, LabeledEdge, NodeEquivalenceComparator}
-import org.jgrapht.graph.{DefaultDirectedGraph, DirectedPseudograph}
-import org.jgrapht.io.{ComponentNameProvider, GraphMLExporter, IntegerComponentNameProvider};
+import net.sansa_stack.inference.utils.graph.{EdgeEquivalenceComparator, LabeledEdge, NodeEquivalenceComparator};
 
 /**
   * @author Lorenz Buehmann
@@ -144,18 +146,38 @@ object GraphUtils {
       }
 
       val edgeLabelProvider = new ComponentNameProvider[LabeledEdge[Rule, TriplePattern]]() {
-        override def getName(e: LabeledEdge[Rule, TriplePattern]): String =
-          FmtUtils.stringForNode(e.label.getPredicate, prefixMapping)
+        override def getName(e: LabeledEdge[Rule, TriplePattern]): String = {
+          val p = e.label.getPredicate
+          // omit if predicate is a variable
+          if(p.isVariable) {
+            ""
+          } else {
+            FmtUtils.stringForNode(e.label.getPredicate, prefixMapping)
+          }
+        }
       }
 
-//      val exporter = new GraphMLExporter[String,LabeledEdge](
+      import org.jgrapht.io.DefaultAttribute
+      val ruleDescriptionProvider = new ComponentAttributeProvider[Rule]() {
+        override def getComponentAttributes(r: Rule): util.Map[String, Attribute] = {
+          val map = new util.HashMap[String, Attribute]()
+          map.put("rule", DefaultAttribute.createAttribute(r.toString))
+          map
+        }
+      }
+
+      //      val exporter = new GraphMLExporter[String,LabeledEdge](
 //        vertexIDProvider, vertexNameProvider, edgeIDProvider,edgeLabelProvider)
 
       val exporter = new GraphMLExporter[Rule, LabeledEdge[Rule, TriplePattern]](
         new IntegerComponentNameProvider[Rule],
         vertexNameProvider,
+        ruleDescriptionProvider,
         new IntegerComponentNameProvider[LabeledEdge[Rule, TriplePattern]],
-        edgeLabelProvider)
+        edgeLabelProvider,
+        null)
+
+      exporter.registerAttribute("rule", AttributeCategory.NODE, AttributeType.STRING)
 
       val fw = new FileWriter(filename)
 

sansa-inference-common/src/test/scala/net/sansa_stack/inference/common/DependencyGraphTest.scala

@@ -1,41 +1,95 @@
 package net.sansa_stack.inference.common
 
+import java.nio.file.{Path, Paths}
+
 import net.sansa_stack.inference.rules._
 import net.sansa_stack.inference.rules.minimizer.DefaultRuleDependencyGraphMinimizer
 import net.sansa_stack.inference.utils.GraphUtils._
 import net.sansa_stack.inference.utils.RuleUtils
 
 /**
+  * Computes a given set of rules and exports its rule dependency graph before and after minimization.
+  *
+  *
   * @author Lorenz Buehmann
   */
 object DependencyGraphTest {
 
+  // the config object
+  case class Config(in: Path = null,
+                    out: Path = null,
+                    profile: String = "",
+                    ruleNames: Seq[String] = Seq()
+                     )
+
+  implicit val pathRead: scopt.Read[Path] =
+    scopt.Read.reads(Paths.get(_))
+
+  // the CLI parser
+  val parser = new scopt.OptionParser[Config]("DependencyGraphTest") {
+
+    head("DependencyGraphTest", "0.1.0")
+
+    opt[Path]('i', "input").required().valueName("<path>").
+      action((x, c) => c.copy(in = x)).
+      text("path to file containing the rules")
+
+    opt[Path]('o', "out").required().valueName("<directory>").
+      action((x, c) => c.copy(out = x)).
+      text("the output directory")
+
+    opt[String]('p', "profile").required().valueName("<profile name>").
+      action((x, c) => c.copy(profile = x)).
+      text("the name of the set of rules to process - will be used for output files")
+
+    opt[Seq[String]]("rules").optional().valueName("<ruleName1>,<ruleName2>,...").
+      action((x, c) => {
+        c.copy(ruleNames = x)
+      }).
+      text("list of rule names to process just a subset of the rules contained in the given input file")
+  }
+
   def main(args: Array[String]): Unit = {
 
-    val path = "/tmp"
+    parser.parse(args, Config()) match {
+      case Some(config) =>
+        run(config)
+      case None =>
+        // scalastyle:off println
+        println(parser.usage)
+      // scalastyle:on println
+    }
+  }
+
+  def run(config: Config): Unit = {
+
+    // make output dirs
+    config.out.toFile.mkdirs()
+
+    // load the rules
+    var rules = RuleUtils.load(config.in.toAbsolutePath.toString)
+
+    // filter if necessary
+    if(config.ruleNames.nonEmpty) {
+      rules = rules.filter(r => config.ruleNames.contains(r.getName))
+    }
 
 //    val names = Seq("rdfp13a", "rdfp13b", "rdfp13c", "rdfs5", "rdfs7") // property rules
-    val names = Seq("rdfp13a", "rdfp13b", "rdfp13c", "rdfs5", "rdfs7", "rdfp3", "rdfp4") // property rules + some instance rules
+    val names = Seq("rdfp13a", "rdfp13b", "rdfp13c")//, "rdfs5", "rdfs7", "rdfp3", "rdfp4") // property rules + some instance rules
 //    val names = Seq("rdfs5", "rdfs7", "rdfp3", "rdfp4") // property TC rule + some instance rules
 
-    // define the rules
-    val rules = RuleSets.OWL_HORST.filter(r => names.contains(r.getName))
-    val profile = ReasoningProfile.OWL_HORST
-//    val rules = RuleSets.RDFS_SIMPLE
-//    val profile = ReasoningProfile.RDFS_SIMPLE
-
     val minimizer = new DefaultRuleDependencyGraphMinimizer()
 
-    // export graphs
-    rules.foreach(rule => RuleUtils.asGraph(rule).export(s"${path}/rule-${rule.getName}.graphml"))
+    // export graphs for each rule
+    rules.foreach(rule => RuleUtils.asGraph(rule).export(config.out.resolve(s"rule_${rule.getName}.graphml").toAbsolutePath.toString))
 
     // generate the rule dependency graph
-    var dependencyGraph = RuleDependencyGraphGenerator.generate(rules)
-    dependencyGraph.export(s"${path}/rdg-${profile}.graphml", true)
+    var dependencyGraph = RuleDependencyGraphGenerator.generate(rules.toSet)
+    dependencyGraph.export(config.out.resolve(s"rdg_${config.profile}.graphml").toAbsolutePath.toString, showInFlowDirection = true)
 
+    // generate the minimized graph
     dependencyGraph = minimizer.execute(dependencyGraph) // RuleDependencyGraphGenerator.generate(rules, pruned = true)
-    dependencyGraph.export(s"${path}/rdg-${profile}-pruned.graphml", true)
-//    dependencyGraph.exportAsPDF(s"${path}/rdg-${profile}-pruned.pdf")
+    dependencyGraph.export(config.out.resolve(s"rdg_${config.profile}_minimized.graphml").toAbsolutePath.toString, showInFlowDirection = true)
 
     // generate the high-level dependency graph
     val highLevelDependencyGraph = HighLevelRuleDependencyGraphGenerator.generate(dependencyGraph)