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)