Skip to content

Commit 5a4127f

Browse files
balhoffbalhoff
committed
Make testable again.
1 parent 70d0488 commit 5a4127f

3 files changed

Lines changed: 42 additions & 40 deletions

File tree

‎build.sbt‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,6 @@ libraryDependencies ++= {
2222
Seq(
2323
"dev.zio" %% "zio" % zioVersion,
2424
"dev.zio" %% "zio-streams" % zioVersion,
25-
"dev.zio" %% "zio-interop-monix" % "3.2.2.0-RC2",
26-
"io.monix" %% "monix" % "3.2.2",
2725
"org.geneontology" %% "whelk-owlapi" % "1.1",
2826
"com.outr" %% "scribe-slf4j" % "3.5.5",
2927
"com.github.alexarchambault" %% "case-app" % "2.0.6",

‎src/main/scala/org/renci/relationgraph/Main.scala‎

Lines changed: 21 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -60,17 +60,7 @@ object Main extends ZCaseApp[Config] {
6060
effectBlockingIO(redundantRDFWriter.triple(Triple.create(NodeFactory.createBlankNode("redundant"), RDFType, OWLOntology))))
6161
.when(config.mode == OWLMode)
6262
start <- ZIO.effectTotal(System.currentTimeMillis())
63-
classes = classHierarchy(whelk)
64-
properties = propertyHierarchy(ontology)
65-
classesStream = allClasses(ontology)
66-
classesTasks = classesStream.map(c => ZIO.effectTotal(processSuperclasses(c, whelk, config)))
67-
queue <- Queue.unbounded[Restriction]
68-
activeRestrictions <- Ref.make(0)
69-
seenRef <- Ref.make(Map.empty[AtomicConcept, Set[AtomicConcept]])
70-
_ <- traverse(specifiedProperties, properties, classes, queue, activeRestrictions, seenRef)
71-
restrictionsStream = Stream.fromQueue(queue).map(r => processRestrictionAndExtendQueue(r, properties, classes, whelk, config.mode, specifiedProperties.isEmpty, queue, activeRestrictions, seenRef))
72-
allTasks = classesTasks ++ restrictionsStream
73-
processed = allTasks.mapMParUnordered(JRuntime.getRuntime.availableProcessors)(identity)
63+
processed <- computeRelations(ontology, whelk, specifiedProperties, config.reflexiveSubclasses.bool, config.equivalenceAsSubclass.bool, config.mode)
7464
_ <- processed.foreach {
7565
case TriplesGroup(nonredundant, redundant) =>
7666
ZIO.effect {
@@ -85,6 +75,21 @@ object Main extends ZCaseApp[Config] {
8575
program.exitCode
8676
}
8777

78+
def computeRelations(ontology: OWLOntology, whelk: ReasonerState, specifiedProperties: Set[AtomicConcept], reflexiveSubclasses: Boolean, equivalenceAsSubclass: Boolean, mode: Config.OutputMode): UIO[UStream[TriplesGroup]] = {
79+
val classes = classHierarchy(whelk)
80+
val properties = propertyHierarchy(ontology)
81+
val classesStream = allClasses(ontology)
82+
val classesTasks = classesStream.map(c => ZIO.effectTotal(processSuperclasses(c, whelk, reflexiveSubclasses, equivalenceAsSubclass)))
83+
for {
84+
queue <- Queue.unbounded[Restriction]
85+
activeRestrictions <- Ref.make(0)
86+
seenRef <- Ref.make(Map.empty[AtomicConcept, Set[AtomicConcept]])
87+
_ <- traverse(specifiedProperties, properties, classes, queue, activeRestrictions, seenRef)
88+
restrictionsStream = Stream.fromQueue(queue).map(r => processRestrictionAndExtendQueue(r, properties, classes, whelk, mode, specifiedProperties.isEmpty, queue, activeRestrictions, seenRef))
89+
allTasks = classesTasks ++ restrictionsStream
90+
} yield allTasks.mapMParUnordered(JRuntime.getRuntime.availableProcessors)(identity)
91+
}
92+
8893
def readPropertiesFile(file: String): ZIO[Blocking, Throwable, Set[AtomicConcept]] =
8994
effectBlocking(Source.fromFile(file, "utf-8")).bracketAuto { source =>
9095
effectBlocking(source.getLines().map(_.trim).filter(_.nonEmpty).map(line => AtomicConcept(line)).to(Set))
@@ -203,23 +208,23 @@ object Main extends ZCaseApp[Config] {
203208
classHierarchy(whelk)
204209
}
205210

206-
def processSuperclasses(cls: OWLClass, whelk: ReasonerState, config: Config): TriplesGroup = {
211+
def processSuperclasses(cls: OWLClass, whelk: ReasonerState, reflexiveSubclasses: Boolean, equivalenceAsSubclass: Boolean): TriplesGroup = {
207212
val subject = NodeFactory.createURI(cls.getIRI.toString)
208213
val concept = AtomicConcept(cls.getIRI.toString)
209214
val allSuperclasses = (whelk.closureSubsBySubclass.getOrElse(concept, Set.empty) - BuiltIn.Top)
210215
.collect { case ac @ AtomicConcept(_) => ac }
211216
if (allSuperclasses(BuiltIn.Bottom)) TriplesGroup.empty //unsatisfiable
212217
else {
213218
val (equivs, directSuperclasses) = whelk.directlySubsumedBy(concept)
214-
val adjustedEquivs = if (config.reflexiveSubclasses.bool) equivs + concept else equivs - concept
219+
val adjustedEquivs = if (reflexiveSubclasses) equivs + concept else equivs - concept
215220
val directSuperclassTriples = directSuperclasses.map(c => Triple.create(subject, RDFSSubClassOf, NodeFactory.createURI(c.id)))
216-
val equivalentClassTriples = if (config.equivalenceAsSubclass.bool)
221+
val equivalentClassTriples = if (equivalenceAsSubclass)
217222
adjustedEquivs.map(c => Triple.create(subject, RDFSSubClassOf, NodeFactory.createURI(c.id)))
218223
else
219224
adjustedEquivs.map(c => Triple.create(subject, OWLEquivalentClass, NodeFactory.createURI(c.id)))
220225
val nonredundantTriples = directSuperclassTriples ++ equivalentClassTriples
221-
val adjustedSuperclasses = if (config.reflexiveSubclasses.bool) allSuperclasses + concept else allSuperclasses - concept
222-
val redundantTriples = if (config.equivalenceAsSubclass.bool)
226+
val adjustedSuperclasses = if (reflexiveSubclasses) allSuperclasses + concept else allSuperclasses - concept
227+
val redundantTriples = if (equivalenceAsSubclass)
223228
adjustedSuperclasses.map(c => Triple.create(subject, RDFSSubClassOf, NodeFactory.createURI(c.id)))
224229
else {
225230
val superclassesMinusEquiv = adjustedSuperclasses -- adjustedEquivs

‎src/test/scala/org/renci/relationgraph/TestRelationGraph.scala‎

Lines changed: 21 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -18,28 +18,27 @@ object TestRelationGraph extends DefaultRunnableSpec {
1818
def spec =
1919
suite("RelationGraphSpec") {
2020
testM("testMaterializedRelations") {
21-
// for {
22-
// manager <- ZIO.effect(OWLManager.createOWLOntologyManager())
23-
// ontology <- ZIO.effect(manager.loadOntologyFromOntologyDocument(this.getClass.getResourceAsStream("materialize_test.ofn")))
24-
// restrictions = Main.extractAllRestrictions(ontology, Set.empty)
25-
// whelkOntology = Bridge.ontologyToAxioms(ontology)
26-
// whelk = Reasoner.assert(whelkOntology)
27-
// results <- restrictions.map(Main.processRestriction(_, whelk, Config.RDFMode)).runCollect
28-
// triples <- ZIO.fromOption(results.reduceOption((left, right) => TriplesGroup(left.nonredundant ++ right.nonredundant, left.redundant ++ right.redundant)))
29-
// TriplesGroup(nonredundant, redundant) = triples
30-
// } yield assert(nonredundant)(contains(Triple.create(n(s"$Prefix#A"), P, n(s"$Prefix#D")))) &&
31-
// assert(redundant)(contains(Triple.create(n(s"$Prefix#A"), P, n(s"$Prefix#D")))) &&
32-
// assert(nonredundant)(not(contains(Triple.create(n(s"$Prefix#C"), P, n(s"$Prefix#D"))))) &&
33-
// assert(redundant)(contains(Triple.create(n(s"$Prefix#C"), P, n(s"$Prefix#D")))) &&
34-
// assert(nonredundant)(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#B")))) &&
35-
// assert(redundant)(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#B")))) &&
36-
// assert(nonredundant)(not(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#C"))))) &&
37-
// assert(redundant)(not(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#C"))))) &&
38-
// assert(nonredundant)(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#C")))) &&
39-
// assert(redundant)(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#C")))) &&
40-
// assert(nonredundant)(not(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#A"))))) &&
41-
// assert(redundant)(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#A"))))
42-
ZIO.succeed(assert(true)(isTrue)) //FIXME
21+
for {
22+
manager <- ZIO.effect(OWLManager.createOWLOntologyManager())
23+
ontology <- ZIO.effect(manager.loadOntologyFromOntologyDocument(this.getClass.getResourceAsStream("materialize_test.ofn")))
24+
whelkOntology = Bridge.ontologyToAxioms(ontology)
25+
whelk = Reasoner.assert(whelkOntology)
26+
resultsStream <- Main.computeRelations(ontology, whelk, Set.empty, false, false, Config.RDFMode)
27+
results <- resultsStream.runCollect
28+
triples <- ZIO.fromOption(results.reduceOption((left, right) => TriplesGroup(left.nonredundant ++ right.nonredundant, left.redundant ++ right.redundant)))
29+
TriplesGroup(nonredundant, redundant) = triples
30+
} yield assert(nonredundant)(contains(Triple.create(n(s"$Prefix#A"), P, n(s"$Prefix#D")))) &&
31+
assert(redundant)(contains(Triple.create(n(s"$Prefix#A"), P, n(s"$Prefix#D")))) &&
32+
assert(nonredundant)(not(contains(Triple.create(n(s"$Prefix#C"), P, n(s"$Prefix#D"))))) &&
33+
assert(redundant)(contains(Triple.create(n(s"$Prefix#C"), P, n(s"$Prefix#D")))) &&
34+
assert(nonredundant)(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#B")))) &&
35+
assert(redundant)(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#B")))) &&
36+
assert(nonredundant)(not(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#C"))))) &&
37+
assert(redundant)(not(contains(Triple.create(n(s"$Prefix#F"), P, n(s"$Prefix#C"))))) &&
38+
assert(nonredundant)(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#C")))) &&
39+
assert(redundant)(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#C")))) &&
40+
assert(nonredundant)(not(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#A"))))) &&
41+
assert(redundant)(contains(Triple.create(n(s"$Prefix#E"), P, n(s"$Prefix#A"))))
4342
}
4443
}
4544

0 commit comments

Comments
 (0)