def HornFromN3(n3Source,additionalBuiltins=None):
from FuXi.Rete.RuleStore import SetupRuleStore, N3RuleStore
if isinstance(n3Source,ConjunctiveGraph):
store=N3RuleStore(additionalBuiltins=additionalBuiltins)
for ctx in n3Source.contexts():
for s,p,o in ctx:
store.add((s,p,o),ctx)
else:
store,graph=SetupRuleStore(n3Source,additionalBuiltins=additionalBuiltins)
store._finalize()
return Ruleset(n3Rules=store.rules,nsMapping=store.nsMgr)
def NetworkFromN3(n3Source,additionalBuiltins=None):
"""
Takes an N3 / RDF conjunctive graph and returns a ReteNetwork
"""
from FuXi.Rete.RuleStore import SetupRuleStore
rule_store, rule_graph, network = SetupRuleStore(
makeNetwork=True,
additionalBuiltins=additionalBuiltins)
for ctx in n3Source.contexts():
for s,p,o in ctx:
rule_store.add((s,p,o),ctx)
rule_store._finalize()
for rule in Ruleset(n3Rules=rule_store.rules,nsMapping=rule_store.nsMgr):
network.buildNetworkFromClause(rule)
return network
def HornFromN3(n3Source,additionalBuiltins=None):
"""
Takes the path or URL of a N3 document, and a mapping from predicates
to functions that implement any builtins found in the N3 document
"""
from FuXi.Rete.RuleStore import SetupRuleStore, N3RuleStore
if isinstance(n3Source,ConjunctiveGraph):
store=N3RuleStore(additionalBuiltins=additionalBuiltins)
for ctx in n3Source.contexts():
for s,p,o in ctx:
store.add((s,p,o),ctx)
else:
store,graph=SetupRuleStore(n3Source,additionalBuiltins=additionalBuiltins)
store._finalize()
return Ruleset(n3Rules=store.rules,nsMapping=store.nsMgr)
def testStratified(self):
bar = EX.Bar
baz = EX.Baz
noBarOrBaz = ~(bar | baz)
omega = EX.Omega
foo = omega & noBarOrBaz
foo.identifier = EX_NS.Foo
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
individual = BNode()
omega.extent = [individual]
NormalFormReduction(self.ontGraph)
self.assertEqual(repr(foo),
'ex:Omega THAT ( NOT ex:Bar ) AND ( NOT ex:Baz )')
posRules, negRules = CalculateStratifiedModel(network, self.ontGraph,
[EX_NS.Foo])
foo.graph = network.inferredFacts
self.failUnless(not posRules,
"There should be no rules in the 0 strata.")
self.assertEqual(
repr(negRules[0]),
"Forall ?X ( ex:Foo(?X) :- And( ex:Omega(?X) not ex:Bar(?X) not ex:Baz(?X) ) )"
)
self.failUnless(
len(negRules) == 1,
"There should only be one negative rule in a higher strata")
self.failUnless(individual in foo.extent,
"%s should be a member of ex:Foo" % individual)
def testGeneralConceptInclusion(self):
# Some Class
# ## Primitive Type ##
# SubClassOf: Class: ex:NoExclusion .
# DisjointWith ( ex:contains some ex:IsolatedCABGConcomitantExclusion )
contains = Property(EX_NS.contains)
testClass = ~(contains | some | EX.Exclusion)
testClass2 = EX.NoExclusion
testClass2 += testClass
NormalFormReduction(self.ontGraph)
individual1 = BNode()
individual2 = BNode()
contains.extent = [(individual1, individual2)]
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
posRules, negRules = CalculateStratifiedModel(network, self.ontGraph,
[EX_NS.NoExclusion])
self.failUnless(not posRules,
"There should be no rules in the 0 strata.")
self.assertEqual(len(negRules), 2,
"There should be 2 'negative' rules")
Individual.factoryGraph = network.inferredFacts
targetClass = Class(EX_NS.NoExclusion, skipOWLClassMembership=False)
self.failUnless(
individual1 in targetClass.extent,
"There is a BNode that bears the contains relation with another individual that is not a member of Exclusion."
)
self.assertEquals(len(list(targetClass.extent)), 1,
"There should only be one member in NoExclusion")
def testNominalPartition(self):
partition = EnumeratedClass(
EX_NS.part,
members=[EX_NS.individual1, EX_NS.individual2, EX_NS.individual3])
subPartition = EnumeratedClass(members=[EX_NS.individual1])
partitionProp = Property(EX_NS.propFoo, range=partition.identifier)
self.testClass = (EX.Bar) & (partitionProp | only | subPartition)
self.testClass.identifier = EX_NS.Foo
self.assertEqual(repr(self.testClass),
'ex:Bar THAT ( ex:propFoo ONLY { ex:individual1 } )')
self.assertEqual(repr(self.testClass.identifier),
"rdflib.term.URIRef(u'http://example.com/Foo')")
NormalFormReduction(self.ontGraph)
self.assertEqual(
repr(self.testClass),
"ex:Bar that ( not ( ex:propFoo value ex:individual2 ) ) and ( not ( ex:propFoo value ex:individual3 ) )"
)
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
ex = BNode()
(EX.Bar).extent = [ex]
self.ontGraph.add((ex, EX_NS.propFoo, EX_NS.individual1))
CalculateStratifiedModel(network, self.ontGraph, [EX_NS.Foo])
self.failUnless((ex, RDF.type, EX_NS.Foo) in network.inferredFacts,
"Missing level 1 predicate (ex:Foo)")
def compile_stage1(model, facts=[], rules=[], **kw):
logging.info("stage1: setting up inference rules")
_, _, network = SetupRuleStore(makeNetwork=True)
for ruleset in rules:
logging.info("stage1: loading rules %s" % ruleset)
for rule in HornFromN3(ruleset):
network.buildNetworkFromClause(rule)
data = Graph()
for factset in facts:
logging.info("stage1: loading facts %s" % factset)
data += Graph().parse(factset, format="turtle")
logging.info("stage1: loading model %s" % model)
data += Graph().parse(model, format="turtle")
logging.info("stage1: generating inferred intermediate representation")
network.inferredFacts = data
network.feedFactsToAdd(generateTokenSet(data))
logging.debug("=")
logging.debug("stage1: output")
logging.debug("-" * 80)
for line in data.serialize(format="turtle").split(b"\n"):
logging.debug(line)
logging.debug("=" * 80)
return data
def __init__(self,
ontology_root=ONTOLOGY_ROOT,
use_rdfs=False,
use_owl=False):
super(FuXiInferenceStore, self).__init__(ontology_root)
(self.rule_store, self.rule_graph,
self.network) = SetupRuleStore(makeNetwork=True)
self.ontology = Graph()
rulesets = []
if use_rdfs:
rulesets.append('rdfs-rules.n3')
else:
# minimum ruleset: only subclassing.
prefix = "@prefix rdfs: <%s>.\n" % (RDFS, )
rules = [
"{?A rdfs:subClassOf ?B. ?S a ?A} => {?S a ?B}.",
"{?P @has rdfs:domain ?C. ?S ?P ?O} => {?S a ?C}.",
"{?P @has rdfs:range ?C. ?S ?P ?O} => {?O a ?C}.",
]
for rule in HornFromN3(StringIO.StringIO(prefix +
"\n".join(rules))):
self.network.buildNetworkFromClause(rule)
if use_owl:
# Does not work yet
rulesets.append('owl-rules.n3')
for ruleset in rulesets:
for rule in HornFromN3(self.as_file(ruleset)):
self.network.buildNetworkFromClause(rule)
def HornFromN3(n3Source, additionalBuiltins=None):
"""
Takes the path or URL of a N3 document, and a mapping from predicates
to functions that implement any builtins found in the N3 document
"""
from FuXi.Rete.RuleStore import SetupRuleStore, N3RuleStore
if isinstance(n3Source, ConjunctiveGraph):
store = N3RuleStore(additionalBuiltins=additionalBuiltins)
for ctx in n3Source.contexts():
for s, p, o in ctx:
store.add((s, p, o), ctx)
else:
store, graph = SetupRuleStore(n3Source,
additionalBuiltins=additionalBuiltins)
store._finalize()
return Ruleset(n3Rules=store.rules, nsMapping=store.nsMgr)
def setUp(self):
self.owlGraph = QueryCountingGraph().parse(StringIO(EX_ONT),
format='n3')
rule_store, rule_graph, self.network = SetupRuleStore(makeNetwork=True)
self.program = self.network.setupDescriptionLogicProgramming(
self.owlGraph, addPDSemantics=False, constructNetwork=False)
self.program.update(AdditionalRules(self.owlGraph))
def handleImport(self):
additionalRules = set()
additionalFacts = set()
for location,profile in self.graph.query(IMPORT_PARTS,
initNs=rif_namespaces):
graph = []
if profile == ENT.RDF:
graph = Graph().parse(location)
additionalFacts.update(graph)
if self.debug:
print "Importing RDF referenced from RIF document"
if profile == ENT['OWL-Direct'] and self.owlEmbeddings:
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
graph = Graph().parse(location)
additionalFacts.update(graph)
additionalRules.update(network.setupDescriptionLogicProgramming(
graph,
addPDSemantics=False,
constructNetwork=False))
if self.debug:
print "Embedded %s rules from %s (imported OWL 2 RL)"%(
len(additionalRules),
location
)
print "Added %s RDF statements from RDF Graph"%(len(graph))
return additionalFacts,additionalRules
def infer():
from rdflib import Graph
from FuXi.Rete.RuleStore import SetupRuleStore
from FuXi.Rete.Util import generateTokenSet
from FuXi.Horn.HornRules import HornFromN3
try:
w = P.Worm()
semnet = w.rdf #fetches the entire worm.db graph
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
closureDeltaGraph = Graph()
network.inferredFacts = closureDeltaGraph
#build a network of rules
for rule in HornFromN3('testrules.n3'):
network.buildNetworkFromClause(rule)
network.feedFactsToAdd(generateTokenSet(semnet)) # apply rules to original facts to infer new facts
# combine original facts with inferred facts
for x in closureDeltaGraph:
w.rdf.add(x)
###uncomment next 4 lines to print inferred facts to human-readable file (demo purposes)
#inferred_facts = closureDeltaGraph.serialize(format='n3') #format inferred facts to notation 3
#inferred = open('what_was_inferred.n3', 'w')
#inferred.write(inferred_facts)
#inferred.close()
except Exception, e:
traceback.print_exc()
def testAtomicNegation(self):
bar = EX.Bar
baz = ~bar
baz.identifier = EX_NS.Baz
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
individual = BNode()
individual2 = BNode()
(EX.OtherClass).extent = [individual]
bar.extent = [individual2]
NormalFormReduction(self.ontGraph)
self.assertEqual(repr(baz), "Class: ex:Baz DisjointWith ex:Bar\n")
posRules, negRules = CalculateStratifiedModel(network, self.ontGraph,
[EX_NS.Foo])
self.failUnless(not posRules,
"There should be no rules in the 0 strata.")
self.failUnless(
len(negRules) == 1,
"There should only be one negative rule in a higher strata")
self.assertEqual(repr(negRules[0]),
"Forall ?X ( ex:Baz(?X) :- not ex:Bar(?X) )")
baz.graph = network.inferredFacts
self.failUnless(individual in baz.extent,
"%s should be a member of ex:Baz" % individual)
self.failUnless(individual2 not in baz.extent,
"%s should *not* be a member of ex:Baz" % individual2)
def testNegatedDisjunctionTest(self):
contains = Property(EX_NS.contains)
omega = EX.Omega
alpha = EX.Alpha
innerDisjunct = omega | alpha
foo = EX.foo
testClass1 = foo & (contains | only | ~innerDisjunct)
testClass1.identifier = EX_NS.Bar
self.assertEqual(
repr(testClass1),
'ex:foo THAT ( ex:contains ONLY ( NOT ( ex:Omega OR ex:Alpha ) ) )'
)
NormalFormReduction(self.ontGraph)
self.assertEqual(
repr(testClass1),
'ex:foo THAT ( NOT ( ex:contains SOME ( ex:Omega OR ex:Alpha ) ) )'
)
individual1 = BNode()
individual2 = BNode()
foo.extent = [individual1]
contains.extent = [(individual1, individual2)]
(EX.Baz).extent = [individual2]
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
posRules, ignored = CalculateStratifiedModel(network, self.ontGraph,
[EX_NS.Bar])
self.failUnless(not posRules,
"There should be no rules in the 0 strata.")
self.assertEqual(len(ignored), 2, "There should be 2 'negative' rules")
testClass1.graph = network.inferredFacts
self.failUnless(individual1 in testClass1.extent,
"%s should be in ex:Bar's extent" % individual1)
def setUp(self):
self.rule_store, self.rule_graph, self.network = SetupRuleStore(
makeNetwork=True)
self.tBoxGraph = Graph().parse(StringIO(TBOX), format='n3')
self.aBoxGraph = Graph().parse(StringIO(ABOX), format='n3')
NormalFormReduction(self.tBoxGraph)
def invokeDecisionProcedure(self, tp, factGraph, bindings, debug,
sipCollection):
isNotGround = first(filter(lambda i: isinstance(i, Variable), tp))
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
bfp = BackwardFixpointProcedure(factGraph,
network,
self.derivedPredicates,
tp,
sipCollection,
hybridPredicates=self.hybridPredicates,
debug=self.DEBUG)
bfp.createTopDownReteNetwork(self.DEBUG)
# rt = bfp.answers(debug=self.DEBUG)
self.queryNetworks.append((bfp.metaInterpNetwork, tp))
self.edbQueries.update(bfp.edbQueries)
if self.DEBUG:
print("Goal/Query: ", tp)
print("Query was not ground" \
if isNotGround is not None else "Query was ground")
if isNotGround is not None:
for item in bfp.goalSolutions:
yield item, None
else:
yield True, None
if debug:
print(bfp.metaInterpNetwork)
bfp.metaInterpNetwork.reportConflictSet(True, sys.stderr)
for query in self.edbQueries:
print("Dispatched query against dataset: ", query.asSPARQL())
def testExistentialInRightOfGCI(self):
someProp = Property(EX_NS.someProp)
existential = someProp | some | EX.Omega
existential += EX.Foo
self.assertEqual(
repr(Class(EX_NS.Foo)),
"Class: ex:Foo SubClassOf: ( ex:someProp SOME ex:Omega )")
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
def setUp(self):
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
self.network = network
self.factGraph = Graph().parse(StringIO(SKOLEM_MACHINE_FACTS),
format='n3')
for rule in HornFromN3(StringIO(SKOLEM_MACHINE_RULES)):
self.network.buildNetworkFromClause(rule)
self.network.feedFactsToAdd(generateTokenSet(self.factGraph))
def test_issue_41(self):
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
for rule in self.rules:
network.buildNetworkFromClause(rule)
def dummy(*av, **kw):
pass
head = (Variable("x"), Variable("y"), Variable("z"))
network.registerReteAction(head, False, dummy)
def testReteActionTest(self):
factGraph = Graph().parse(StringIO(N3_FACTS), format='n3')
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
for rule in HornFromN3(StringIO(N3_PROGRAM), additionalBuiltins=None):
network.buildNetworkFromClause(rule)
network.registerReteAction(matchingHeadTriple, False, encodeAction)
network.feedFactsToAdd(generateTokenSet(factGraph))
print(network.inferredFacts.serialize(format='n3'))
self.failUnless(resultingTriple in network.inferredFacts)
def setUp(self):
self.ruleStore,self.ruleGraph=SetupRuleStore(StringIO(PROGRAM2))
self.ruleStore._finalize()
self.ruleStrings=[
'Forall ?Y ?X ( :sg_bf(?X ?Y) :- And( :sg_magic(?X) ex:flat(?X ?Y) ) )',
'Forall ( :sg_magic(?Z1) :- And( :sg_magic(?X) ex:up(?X ?Z1) ) )',
'Forall ?Z4 ?Y ?X ?Z1 ?Z2 ?Z3 ( :sg_bf(?X ?Y) :- And( :sg_magic(?X) ex:up(?X ?Z1) :sg_magic(?Z1) :sg_bf(?Z1 ?Z2) ex:flat(?Z2 ?Z3) :sg_magic(?Z3) :sg_bf(?Z3 ?Z4) ex:down(?Z4 ?Y) ) )',
'Forall ( :sg_magic(?Z3) :- And( :sg_magic(?X) ex:up(?X ?Z1) :sg_bf(?Z1 ?Z2) ex:flat(?Z2 ?Z3) ) )',
]
def SetupMetaInterpreter(tBoxGraph, goal, useThingRule=True):
from FuXi.LP.BackwardFixpointProcedure import BackwardFixpointProcedure
from FuXi.Rete.Magic import SetupDDLAndAdornProgram
from FuXi.Horn.PositiveConditions import BuildUnitermFromTuple
from FuXi.Rete.TopDown import PrepareSipCollection
from FuXi.DLP import LloydToporTransformation, makeRule
from FuXi.Rete.SidewaysInformationPassing import GetOp
owlThingAppears = False
if useThingRule and OWL.Thing in tBoxGraph.all_nodes():
owlThingAppears = True
completionRules = HornFromN3(StringIO(RULES))
if owlThingAppears:
completionRules.formulae.extend(
HornFromN3(StringIO(CONDITIONAL_THING_RULE)))
reducedCompletionRules = set()
for rule in completionRules:
for clause in LloydToporTransformation(rule.formula):
rule = makeRule(clause, {})
# log.debug(rule)
# PrettyPrintRule(rule)
reducedCompletionRules.add(rule)
network = SetupRuleStore(makeNetwork=True)[-1]
SetupDDLAndAdornProgram(
tBoxGraph,
reducedCompletionRules,
[goal],
derivedPreds=derivedPredicates,
ignoreUnboundDPreds=True,
hybridPreds2Replace=hybridPredicates)
lit = BuildUnitermFromTuple(goal)
op = GetOp(lit)
lit.setOperator(URIRef(op + u'_derived'))
goal = lit.toRDFTuple()
sipCollection = PrepareSipCollection(reducedCompletionRules)
tBoxGraph.templateMap = {}
bfp = BackwardFixpointProcedure(
tBoxGraph,
network,
derivedPredicates,
goal,
sipCollection,
hybridPredicates=hybridPredicates,
debug=True)
bfp.createTopDownReteNetwork(True)
log.debug(reducedCompletionRules)
rt = bfp.answers(debug=True)
log.debug(rt)
log.debug(bfp.metaInterpNetwork)
bfp.metaInterpNetwork.reportConflictSet(True, sys.stderr)
for query in bfp.edbQueries:
log.debug("Dispatched query against dataset: ", query.asSPARQL())
log.debug(list(bfp.goalSolutions))
def testExistentialInRightOfGCI(self):
someProp = Property(EX_NS.someProp)
existential = someProp | some | EX.Omega
existential += EX.Foo
self.assertEqual(
repr(Class(EX_NS.Foo)),
"Class: ex:Foo SubClassOf: ( ex:someProp SOME ex:Omega )")
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
rules = network.setupDescriptionLogicProgramming(
self.ontGraph, addPDSemantics=False, constructNetwork=False)
def test_hornfromn3_inferencing(self):
# https://groups.google.com/d/msg/fuxi-discussion/4r1Nt_o1Hco/4QQ7BaqBCH8J
from io import StringIO
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
for rule in HornFromN3(StringIO(rules)):
network.buildNetworkFromClause(rule)
g = Graph()
g.parse(data=facts, format="n3")
network.feedFactsToAdd(generateTokenSet(g))
print(network.inferredFacts.serialize(format="n3").decode('utf-8'))
def build_network2(rules):
graph = ConjunctiveGraph()
graph.load(StringIO(rules), publicID='test', format='n3')
rule_store, rule_graph = SetupRuleStore(
StringIO(rules),
additionalBuiltins={STRING_NS.startsWith: StringStartsWith})
from FuXi.Rete.Network import ReteNetwork
network = ReteNetwork(rule_store)
network.feedFactsToAdd(generateTokenSet(extractBaseFacts(graph)))
return network
def test_hornfromn3(self):
self.rule_store, self.rule_graph, self.network = SetupRuleStore(
makeNetwork=True)
closureDeltaGraph = Graph()
self.network.inferredFacts = closureDeltaGraph
for rule in HornFromN3('http://www.agfa.com/w3c/euler/rdfs-rules.n3',
additionalBuiltins=None):
self.network.buildNetworkFromClause(rule)
print("{} {}".format(self.network, rule))
# state_before_inferencing = str(self.network)
self.network.feedFactsToAdd(
generateTokenSet(self.network.inferredFacts))
def testBasePredicateEquivalence(self):
(EX.Foo).equivalentClass = [EX.Bar]
self.assertEqual(repr(Class(EX_NS.Foo)),
"Class: ex:Foo EquivalentTo: ex:Bar")
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
rules = network.setupDescriptionLogicProgramming(
self.ontGraph, addPDSemantics=False, constructNetwork=False)
self.assertEqual(
repr(rules),
'set([Forall ?X ( ex:Bar(?X) :- ex:Foo(?X) ), Forall ?X ( ex:Foo(?X) :- ex:Bar(?X) )])'
)
self.assertEqual(len(rules), 2, "There should be 2 rules")
class AdornProgramTest(unittest.TestCase):
def setUp(self):
self.ruleStore,self.ruleGraph=SetupRuleStore(StringIO(PROGRAM2))
self.ruleStore._finalize()
self.ruleStrings=[
'Forall ?Y ?X ( :sg_bf(?X ?Y) :- And( :sg_magic(?X) ex:flat(?X ?Y) ) )',
'Forall ( :sg_magic(?Z1) :- And( :sg_magic(?X) ex:up(?X ?Z1) ) )',
'Forall ?Z4 ?Y ?X ?Z1 ?Z2 ?Z3 ( :sg_bf(?X ?Y) :- And( :sg_magic(?X) ex:up(?X ?Z1) :sg_magic(?Z1) :sg_bf(?Z1 ?Z2) ex:flat(?Z2 ?Z3) :sg_magic(?Z3) :sg_bf(?Z3 ?Z4) ex:down(?Z4 ?Y) ) )',
'Forall ( :sg_magic(?Z3) :- And( :sg_magic(?X) ex:up(?X ?Z1) :sg_bf(?Z1 ?Z2) ex:flat(?Z2 ?Z3) ) )',
]
def testAdorn(self):
fg=Graph().parse(StringIO(PROGRAM2),format='n3')
rules=Ruleset(n3Rules=self.ruleGraph.store.rules,
nsMapping=self.ruleStore.nsMgr)
from pprint import pprint;pprint(self.ruleStrings)
for rule in MagicSetTransformation(fg,
rules,
NON_LINEAR_MS_QUERY,
[MAGIC.sg]):
self.failUnless(repr(rule) in self.ruleStrings, repr(rule))
def __init__(self, ontology_root=DEFAULT_ROOT, use_owl=False):
super(FuXiInferenceStore, self).__init__(ontology_root)
(self.rule_store, self.rule_graph, self.network) = SetupRuleStore(
makeNetwork=True)
self.use_owl = use_owl
self.ontology = Graph()
rulesets = ['rdfs-rules.n3']
if self.use_owl:
# Does not work yet
rulesets.append('owl-rules.n3')
for ruleset in rulesets:
for rule in HornFromN3(self.as_file(ruleset)):
self.network.buildNetworkFromClause(rule)
def testGCIConDisjunction(self):
conjunct = EX.Foo & (EX.Omega | EX.Alpha)
(EX.Bar) += conjunct
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
rules = network.setupDescriptionLogicProgramming(
self.ontGraph,
derivedPreds=[EX_NS.Bar],
addPDSemantics=False,
constructNetwork=False)
self.assertEqual(
repr(rules),
'set([Forall ?X ( ex:Bar(?X) :- And( ex:Foo(?X) ex:Alpha(?X) ) ), Forall ?X ( ex:Bar(?X) :- And( ex:Foo(?X) ex:Omega(?X) ) )])'
)
self.assertEqual(len(rules), 2, "There should be 2 rules")
def testValueRestrictionInLeftOfGCI(self):
someProp = Property(EX_NS.someProp)
leftGCI = (someProp | value | EX.fish) & EX.Bar
foo = EX.Foo
foo += leftGCI
self.assertEqual(
repr(leftGCI),
'ex:Bar THAT ( ex:someProp VALUE <http://example.com/fish> )')
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
rules = network.setupDescriptionLogicProgramming(
self.ontGraph, addPDSemantics=False, constructNetwork=False)
self.assertEqual(
repr(rules), "set([Forall ?X ( ex:Foo(?X) :- " +
"And( ex:someProp(?X ex:fish) ex:Bar(?X) ) )])")
def setUp(self):
self.tBoxGraph = Graph()
self.tBoxGraph.namespace_manager.bind('ex', EX)
self.tBoxGraph.namespace_manager.bind('owl', OWL_NS)
Individual.factoryGraph = self.tBoxGraph
self.classB = Class(EX.b)
self.classE = Class(EX.e)
self.classF = Class(EX.f)
self.classA = BooleanClass(EX.a,
operator=OWL_NS.unionOf,
members=[self.classE, self.classF])
self.classC = BooleanClass(EX.c,
operator=OWL_NS.unionOf,
members=[self.classA, self.classB])
self.ruleStore, self.ruleGraph = SetupRuleStore()
def infer(graph):
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
rules = HornFromN3(
os.path.join(os.path.dirname(os.path.realpath(__file__)), 'rules.n3'))
closure_delta = Graph()
network.inferredFacts = closure_delta
for rule in rules:
network.buildNetworkFromClause(rule)
network.feedFactsToAdd(generateTokenSet(graph))
new_graph = graph + closure_delta
# Send to ingest
http.post('http://localhost:5200/', new_graph.serialize(format='json-ld'))
def NetworkFromN3(n3Source, additionalBuiltins=None):
"""Take an N3 / RDF conjunctive graph and return a ReteNetwork.
Network is built from the rules in the N3 graph
"""
from FuXi.Rete.RuleStore import SetupRuleStore
rule_store, rule_graph, network = SetupRuleStore(
makeNetwork=True, additionalBuiltins=additionalBuiltins)
if isinstance(n3Source, ConjunctiveGraph):
for ctx in n3Source.contexts():
for s, p, o in ctx:
rule_store.add((s, p, o), ctx)
else:
for s, p, o in n3Source:
rule_store.add((s, p, o), n3Source)
rule_store._finalize()
for rule in Ruleset(n3Rules=rule_store.rules, nsMapping=rule_store.nsMgr):
network.buildNetworkFromClause(rule)
return network
def HornFromDL(owlGraph,
safety=DATALOG_SAFETY_NONE,
derivedPreds=[],
complSkip=[]):
"""
Takes an OWL RDF graph, an indication of what level of ruleset safety
(see: http://code.google.com/p/fuxi/wiki/FuXiUserManual#Rule_Safety) to apply,
and a list of derived predicates and returns a Ruleset instance comprised of
the rules extracted from the OWL RDF graph (using a variation of the OWL 2 RL transformation)
"""
from FuXi.Rete.RuleStore import SetupRuleStore
ruleStore, ruleGraph, network = SetupRuleStore(makeNetwork=True)
return network.setupDescriptionLogicProgramming(owlGraph,
derivedPreds=derivedPreds,
expanded=complSkip,
addPDSemantics=False,
constructNetwork=False,
safety=safety)
