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 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 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 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 GetELHConsequenceProcedureRules(tBoxGraph, useThingRule=True):
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, {})
# print rule
# PrettyPrintRule(rule)
reducedCompletionRules.add(rule)
return reducedCompletionRules
def reason_func(resource_name):
famNs = Namespace('file:///code/ganglia/metric.n3#')
nsMapping = {'mtc': famNs}
rules = HornFromN3('ganglia/metric/metric_rule.n3')
factGraph = Graph().parse('ganglia/metric/metric.n3', format='n3')
factGraph.bind('mtc', famNs)
dPreds = [famNs.relateTo]
topDownStore = TopDownSPARQLEntailingStore(factGraph.store,
factGraph,
idb=rules,
derivedPredicates=dPreds,
nsBindings=nsMapping)
targetGraph = Graph(topDownStore)
targetGraph.bind('ex', famNs)
#get list of the related resource
r_list = list(
targetGraph.query('SELECT ?RELATETO { mtc:%s mtc:relateTo ?RELATETO}' %
resource_name,
initNs=nsMapping))
res_list = []
for res in r_list:
res_list.append(str(res).split("#")[1])
return res_list
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_13(self):
"""Test issue 13.
https://github.com/RDFLib/FuXi/issues/13
"""
rules = HornFromN3('http://www.agfa.com/w3c/euler/rdfs-rules.n3')
for rule in rules:
assert 'And( )' not in str(rule), str(rule)
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 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 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 __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 testTransitivity(self):
nsBindings={u'owl':OWL_NS,u'ex':EX}
topDownStore=TopDownSPARQLEntailingStore(
self.graph.store,
self.graph,
idb=HornFromN3(StringIO(RULES)),
DEBUG=True,
derivedPredicates = [OWL_NS.sameAs],
nsBindings=nsBindings,
hybridPredicates = [OWL_NS.sameAs])
targetGraph = Graph(topDownStore)
for query,solns in QUERIES.items():
result = set(targetGraph.query(query,initNs=nsBindings))
print query,result
self.failUnless(not solns.difference(result))
def setupDescriptionLogicProgramming(self,
owlN3Graph,
expanded=[],
addPDSemantics=True,
classifyTBox=False,
constructNetwork=True,
derivedPreds=[],
ignoreNegativeStratus=False,
safety=DATALOG_SAFETY_NONE):
rt = [
rule for rule in MapDLPtoNetwork(
self,
owlN3Graph,
complementExpansions=expanded,
constructNetwork=constructNetwork,
derivedPreds=derivedPreds,
ignoreNegativeStratus=ignoreNegativeStratus,
safety=safety)
]
if ignoreNegativeStratus:
rules, negRules = rt
rules = set(rules)
self.negRules = set(negRules)
else:
rules = set(rt)
if constructNetwork:
self.rules.update(rules)
additionalRules = set(AdditionalRules(owlN3Graph))
if addPDSemantics:
from FuXi.Horn.HornRules import HornFromN3
additionalRules.update(HornFromN3(StringIO(non_DHL_OWL_Semantics)))
if constructNetwork:
for rule in additionalRules:
self.buildNetwork(iter(rule.formula.body),
iter(rule.formula.head), rule)
self.rules.add(rule)
else:
rules.update(additionalRules)
if constructNetwork:
rules = self.rules
# noRules = len(rules)
if classifyTBox:
self.feedFactsToAdd(generateTokenSet(owlN3Graph))
# print("##### DLP rules fired against OWL/RDF TBOX", self)
return rules
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 setUp(self):
self.famNs = Namespace('http://dev.w3.org/2000/10/swap/test/cwm/fam.n3#')
self.nsMapping = dict(fam=self.famNs)
# self.rules = HornFromN3('http://dev.w3.org/2000/10/swap/test/cwm/fam-rules.n3')
self.rules = HornFromN3(StringIO(rules))
# self.factGraph = Graph().parse(
# 'http://dev.w3.org/2000/10/swap/test/cwm/fam.n3', format='n3')
self.factGraph = Graph().parse(StringIO(facts), format='n3')
self.factGraph.bind('fam', self.famNs)
self.factGraph.bind('', self.famNs)
dPreds = [self.famNs.ancestor]
self.topDownStore = TopDownSPARQLEntailingStore(
self.factGraph.store,
self.factGraph,
idb=self.rules,
derivedPredicates=dPreds,
nsBindings=self.nsMapping)
def WhichSubsumptionOperand(term, owlGraph):
topDownStore = TopDownSPARQLEntailingStore(
owlGraph.store,
owlGraph,
idb=HornFromN3(StringIO(SUBSUMPTION_SEMANTICS)),
DEBUG=False,
derivedPredicates=[OWL_NS.sameAs],
hybridPredicates=[OWL_NS.sameAs])
targetGraph = Graph(topDownStore)
appearsLeft = targetGraph.query("ASK { <%s> rdfs:subClassOf [] } ",
initNs={u'rdfs': RDFS})
appearsRight = targetGraph.query("ASK { [] rdfs:subClassOf <%s> } ",
initNs={u'rdfs': RDFS})
if appearsLeft and appearsRight:
return BOTH_SUBSUMPTION_OPERAND
elif appearsLeft:
return LEFT_SUBSUMPTION_OPERAND
else:
return RIGHT_SUBSUMPTION_OPERAND
def __init__(self, ontology_root=DEFAULT_ROOT, use_owl=False):
from FuXi.Horn.HornRules import HornFromN3
from FuXi.Rete.Util import generateTokenSet
from FuXi.Rete.RuleStore import SetupRuleStore
# from FuXi.Rete.Network import ReteNetwork
# from FuXi.Horn import (
# DATALOG_SAFETY_NONE, DATALOG_SAFETY_STRICT, DATALOG_SAFETY_LOOSE)
# from FuXi.Horn.HornRules import NetworkFromN3, HornFromDL
super(FuXiInferenceStore, self).__init__(ontology_root)
(self.rule_store, self.rule_graph, self.network) = SetupRuleStore(
makeNetwork=True)
self.use_owl = use_owl
rulesets = ['cache/rdfs-rules.n3']
if self.use_owl:
# Does not work yet
rulesets.append('cache/owl-rules.n3')
for ruleset in rulesets:
for rule in HornFromN3(self.as_file(ruleset)):
self.network.buildNetworkFromClause(rule)
def main():
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
closureDeltaGraph = Graph()
network.inferredFacts = closureDeltaGraph
print("N0", network)
hornrules = HornFromN3(
'http://fuxi.googlecode.com/hg/test/sameAsTestRules.n3')
for rule in hornrules:
network.buildNetworkFromClause(rule)
print("N1", network)
factGraph = Graph().parse(
'http://fuxi.googlecode.com/hg/test/sameAsTestFacts.n3', format='n3')
network.feedFactsToAdd(generateTokenSet(factGraph))
print(closureDeltaGraph.serialize(format='n3'))
def infer(self):
""" Fire FuXi rule engine to infer triples """
from FuXi.Rete.RuleStore import SetupRuleStore
from FuXi.Rete.Util import generateTokenSet
from FuXi.Horn.HornRules import HornFromN3
# fetch the derived object's graph
semnet = self.rdf
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)
# apply rules to original facts to infer new facts
network.feedFactsToAdd(generateTokenSet(semnet))
# combine original facts with inferred facts
for x in closureDeltaGraph:
self.rdf.add(x)
def AdditionalRules(tBox):
"""
Only include list and oneOf semantics if oneOf axiom is detected in graph
reduce computational complexity. Same with other conditional axioms
"""
from FuXi.Horn.HornRules import HornFromN3
try:
from functools import reduce
assert reduce
except ImportError:
pass
try:
from io import StringIO
assert StringIO
except ImportError:
from StringIO import StringIO
from rdflib import RDF
from FuXi.Syntax.InfixOWL import OWL_NS
ruleSrc = set()
addListSemantics = False
if tBox.query(FUNCTIONAL_PROPERTIES, initNs={"owl": OWL_NS}).askAnswer:
ruleSrc.add(FUNCTIONAL_SEMANTICS)
if (None, OWL_NS.oneOf, None) in tBox:
ruleSrc.add(NOMINAL_SEMANTICS)
addListSemantics = True
if (None, RDF.type, OWL_NS.AllDifferent) in tBox:
ruleSrc.add(DIFFERENT_FROM_SEMANTICS)
addListSemantics = True
if addListSemantics:
ruleSrc.add(LIST_MEMBERSHIP_SEMANTICS)
for src in ruleSrc:
for rule in HornFromN3(StringIO(src)):
yield rule
def build_rule_network(rulesets):
"""
:param rulesets: iterable of n3 ruleset paths
:returns: Initialized **in-memory** Rule network
"""
# Build Rule Network
rule_store, rule_graph, network = SetupRuleStore(None, None, True)
network.inferredFacts = Graph() # raptor_world
for ruleset_path in rulesets:
logging.debug("Loading rules from: %r" % ruleset_path)
len_pre = len(network.rules)
for rule in HornFromN3(ruleset_path):
network.buildNetworkFromClause(rule)
len_post = len(network.rules)
logging.debug(" %r : %d rules (%d -> %d)" %
(ruleset_path, len_post - len_pre, len_pre, len_post))
return network
def main():
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
closureDeltaGraph = Graph()
network.inferredFacts = closureDeltaGraph
print("N0", network)
hornrules = HornFromN3(
'https://raw.githubusercontent.com/RDFLib/FuXi/master/test/sameAsTestRules.n3'
)
for rule in hornrules:
network.buildNetworkFromClause(rule)
print("N1", network)
factGraph = Graph().parse(
'https://raw.githubusercontent.com/RDFLib/FuXi/master/test/sameAsTestFacts.n3',
format='n3')
network.feedFactsToAdd(generateTokenSet(factGraph))
print(closureDeltaGraph.serialize(format='n3'))
def AdditionalRules(tBox):
"""
Only include list and oneOf semantics
if oneOf axiom is detected in graph
reduce computational complexity. Same with other conditional axioms
"""
ruleSrc = set()
addListSemantics = False
if tBox.query(FUNCTIONAL_PROPERTIES, initNs={"owl": OWL_NS}).askAnswer[0]:
ruleSrc.add(FUNCTIONAL_SEMANTCS)
if (None, OWL_NS.oneOf, None) in tBox:
ruleSrc.add(NOMINAL_SEMANTICS)
addListSemantics = True
if (None, RDF.type, OWL_NS.AllDifferent) in tBox:
ruleSrc.add(DIFFERENT_FROM_SEMANTICS)
addListSemantics = True
if addListSemantics:
ruleSrc.add(LIST_MEMBERSHIP_SEMANTICS)
for src in ruleSrc:
for rule in HornFromN3(StringIO(src)):
yield rule
def test_make_inference(self):
"""
Tests that the rule engine is able to fire and make an inference.
This passes if any inference at all is generated.
"""
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
closureDeltaGraph = Graph()
network.inferredFacts = closureDeltaGraph
for rule in HornFromN3('tests/fuxi_test_files/rules.n3'):
network.buildNetworkFromClause(rule)
factGraph = Graph().parse('tests/fuxi_test_files/facts.n3',
format='n3')
network.feedFactsToAdd(generateTokenSet(factGraph))
inferred_facts = list(closureDeltaGraph.objects())
assert len(inferred_facts) > 0
def setUp(self):
self.rules = HornFromN3(StringIO(rule_fixture))
def main():
from optparse import OptionParser
op = OptionParser(
'usage: %prog [options] factFile1 factFile2 ... factFileN')
op.add_option(
'--why',
default=None,
help='Specifies the goals to solve for using the non-naive methods' +
'see --method')
op.add_option(
'--closure',
action='store_true',
default=False,
help='Whether or not to serialize the inferred triples' +
' along with the original triples. Otherwise ' +
'(the default behavior), serialize only the inferred triples')
op.add_option(
'--imports',
action='store_true',
default=False,
help='Whether or not to follow owl:imports in the fact graph')
op.add_option(
'--output',
default='n3',
metavar='RDF_FORMAT',
choices=[
'xml', 'TriX', 'n3', 'pml', 'proof-graph', 'nt', 'rif', 'rif-xml',
'conflict', 'man-owl'
],
help=
"Serialize the inferred triples and/or original RDF triples to STDOUT "
+
"using the specified RDF syntax ('xml', 'pretty-xml', 'nt', 'turtle', "
+
"or 'n3') or to print a summary of the conflict set (from the RETE " +
"network) if the value of this option is 'conflict'. If the the " +
" value is 'rif' or 'rif-xml', Then the rules used for inference " +
"will be serialized as RIF. If the value is 'pml' and --why is used, "
+ " then the PML RDF statements are serialized. If output is " +
"'proof-graph then a graphviz .dot file of the proof graph is printed. "
+
"Finally if the value is 'man-owl', then the RDF facts are assumed " +
"to be OWL/RDF and serialized via Manchester OWL syntax. The default is %default"
)
op.add_option(
'--class',
dest='classes',
action='append',
default=[],
metavar='QNAME',
help='Used with --output=man-owl to determine which ' +
'classes within the entire OWL/RDF are targetted for serialization' +
'. Can be used more than once')
op.add_option(
'--hybrid',
action='store_true',
default=False,
help='Used with with --method=bfp to determine whether or not to ' +
'peek into the fact graph to identify predicates that are both ' +
'derived and base. This is expensive for large fact graphs' +
'and is explicitely not used against SPARQL endpoints')
op.add_option(
'--property',
action='append',
dest='properties',
default=[],
metavar='QNAME',
help='Used with --output=man-owl or --extract to determine which ' +
'properties are serialized / extracted. Can be used more than once')
op.add_option(
'--normalize',
action='store_true',
default=False,
help=
"Used with --output=man-owl to attempt to determine if the ontology is 'normalized' [Rector, A. 2003]"
+ "The default is %default")
op.add_option(
'--ddlGraph',
default=False,
help=
"The location of a N3 Data Description document describing the IDB predicates"
)
op.add_option(
'--input-format',
default='xml',
dest='inputFormat',
metavar='RDF_FORMAT',
choices=['xml', 'trix', 'n3', 'nt', 'rdfa'],
help=
"The format of the RDF document(s) which serve as the initial facts " +
" for the RETE network. One of 'xml', 'n3', 'trix', 'nt', " +
"or 'rdfa'. The default is %default")
op.add_option(
'--safety',
default='none',
metavar='RULE_SAFETY',
choices=['loose', 'strict', 'none'],
help="Determines how to handle RIF Core safety. A value of 'loose' " +
" means that unsafe rules will be ignored. A value of 'strict' " +
" will cause a syntax exception upon any unsafe rule. A value of " +
"'none' (the default) does nothing")
op.add_option(
'--pDSemantics',
action='store_true',
default=False,
help=
'Used with --dlp to add pD semantics ruleset for semantics not covered '
+ 'by DLP but can be expressed in definite Datalog Logic Programming' +
' The default is %default')
op.add_option(
'--stdin',
action='store_true',
default=False,
help=
'Parse STDIN as an RDF graph to contribute to the initial facts. The default is %default '
)
op.add_option(
'--ns',
action='append',
default=[],
metavar="PREFIX=URI",
help='Register a namespace binding (QName prefix to a base URI). This '
+ 'can be used more than once')
op.add_option(
'--rules',
default=[],
action='append',
metavar='PATH_OR_URI',
help='The Notation 3 documents to use as rulesets for the RETE network'
+ '. Can be specified more than once')
op.add_option('-d',
'--debug',
action='store_true',
default=True,
help='Include debugging output')
op.add_option(
'--strictness',
default='defaultBase',
metavar='DDL_STRICTNESS',
choices=['loose', 'defaultBase', 'defaultDerived', 'harsh'],
help=
'Used with --why to specify whether to: *not* check if predicates are '
+
' both derived and base (loose), if they are, mark as derived (defaultDerived) '
+
'or as base (defaultBase) predicates, else raise an exception (harsh)')
op.add_option(
'--method',
default='naive',
metavar='reasoning algorithm',
choices=['gms', 'bfp', 'naive'],
help='Used with --why to specify how to evaluate answers for query. '
+ 'One of: gms, sld, bfp, naive')
op.add_option(
'--firstAnswer',
default=False,
action='store_true',
help=
'Used with --why to determine whether to fetch all answers or just ' +
'the first')
op.add_option(
'--edb',
default=[],
action='append',
metavar='EXTENSIONAL_DB_PREDICATE_QNAME',
help=
'Used with --why/--strictness=defaultDerived to specify which clashing '
+ 'predicate will be designated as a base predicate')
op.add_option(
'--idb',
default=[],
action='append',
metavar='INTENSIONAL_DB_PREDICATE_QNAME',
help=
'Used with --why/--strictness=defaultBase to specify which clashing ' +
'predicate will be designated as a derived predicate')
op.add_option(
'--hybridPredicate',
default=[],
action='append',
metavar='PREDICATE_QNAME',
help=
'Used with --why to explicitely specify a hybrid predicate (in both ' +
' IDB and EDB) ')
op.add_option(
'--noMagic',
default=[],
action='append',
metavar='DB_PREDICATE_QNAME',
help='Used with --why to specify that the predicate shouldnt have its '
+ 'magic sets calculated')
op.add_option(
'--filter',
action='append',
default=[],
metavar='PATH_OR_URI',
help=
'The Notation 3 documents to use as a filter (entailments do not particpate in network)'
)
op.add_option(
'--ruleFacts',
action='store_true',
default=False,
help="Determines whether or not to attempt to parse initial facts from "
+ "the rule graph. The default is %default")
op.add_option(
'--builtins',
default=False,
metavar='PATH_TO_PYTHON_MODULE',
help="The path to a python module with function definitions (and a " +
"dicitonary called ADDITIONAL_FILTERS) to use for builtins implementations"
)
op.add_option(
'--dlp',
action='store_true',
default=False,
help=
'Use Description Logic Programming (DLP) to extract rules from OWL/RDF. The default is %default'
)
op.add_option(
'--sparqlEndpoint',
action='store_true',
default=False,
help=
'Indicates that the sole argument is the URI of a SPARQL endpoint to query'
)
op.add_option(
'--ontology',
action='append',
default=[],
metavar='PATH_OR_URI',
help=
'The path to an OWL RDF/XML graph to use DLP to extract rules from ' +
'(other wise, fact graph(s) are used) ')
op.add_option(
'--ontologyFormat',
default='xml',
dest='ontologyFormat',
metavar='RDF_FORMAT',
choices=['xml', 'trix', 'n3', 'nt', 'rdfa'],
help=
"The format of the OWL RDF/XML graph specified via --ontology. The default is %default"
)
op.add_option(
'--builtinTemplates',
default=None,
metavar='N3_DOC_PATH_OR_URI',
help=
'The path to an N3 document associating SPARQL FILTER templates to ' +
'rule builtins')
op.add_option('--negation',
action='store_true',
default=False,
help='Extract negative rules?')
op.add_option(
'--normalForm',
action='store_true',
default=False,
help='Whether or not to reduce DL axioms & LP rules to a normal form')
(options, facts) = op.parse_args()
nsBinds = {'iw': 'http://inferenceweb.stanford.edu/2004/07/iw.owl#'}
for nsBind in options.ns:
pref, nsUri = nsBind.split('=')
nsBinds[pref] = nsUri
namespace_manager = NamespaceManager(Graph())
if options.sparqlEndpoint:
factGraph = Graph(plugin.get('SPARQLStore', Store)(facts[0]))
options.hybrid = False
else:
factGraph = Graph()
ruleSet = Ruleset()
for fileN in options.rules:
if options.ruleFacts and not options.sparqlEndpoint:
factGraph.parse(fileN, format='n3')
print("Parsing RDF facts from ", fileN)
if options.builtins:
import imp
userFuncs = imp.load_source('builtins', options.builtins)
rs = HornFromN3(fileN,
additionalBuiltins=userFuncs.ADDITIONAL_FILTERS)
else:
rs = HornFromN3(fileN)
nsBinds.update(rs.nsMapping)
ruleSet.formulae.extend(rs)
#ruleGraph.parse(fileN, format='n3')
ruleSet.nsMapping = nsBinds
for prefix, uri in list(nsBinds.items()):
namespace_manager.bind(prefix, uri, override=False)
closureDeltaGraph = Graph()
closureDeltaGraph.namespace_manager = namespace_manager
factGraph.namespace_manager = namespace_manager
if not options.sparqlEndpoint:
for fileN in facts:
factGraph.parse(fileN, format=options.inputFormat)
if options.imports:
for owlImport in factGraph.objects(predicate=OWL_NS.imports):
factGraph.parse(owlImport)
print("Parsed Semantic Web Graph.. ", owlImport)
if not options.sparqlEndpoint and facts:
for pref, uri in factGraph.namespaces():
nsBinds[pref] = uri
if options.stdin:
assert not options.sparqlEndpoint, "Cannot use --stdin with --sparqlEndpoint"
factGraph.parse(sys.stdin, format=options.inputFormat)
#Normalize namespace mappings
#prune redundant, rdflib-allocated namespace prefix mappings
newNsMgr = NamespaceManager(factGraph)
from FuXi.Rete.Util import CollapseDictionary
for k, v in list(
CollapseDictionary(
dict([(k, v) for k, v in factGraph.namespaces()])).items()):
newNsMgr.bind(k, v)
factGraph.namespace_manager = newNsMgr
if options.normalForm:
NormalFormReduction(factGraph)
if not options.sparqlEndpoint:
workingMemory = generateTokenSet(factGraph)
if options.builtins:
import imp
userFuncs = imp.load_source('builtins', options.builtins)
rule_store, rule_graph, network = SetupRuleStore(
makeNetwork=True, additionalBuiltins=userFuncs.ADDITIONAL_FILTERS)
else:
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
network.inferredFacts = closureDeltaGraph
network.nsMap = nsBinds
if options.dlp:
from FuXi.DLP.DLNormalization import NormalFormReduction
if options.ontology:
ontGraph = Graph()
for fileN in options.ontology:
ontGraph.parse(fileN, format=options.ontologyFormat)
for prefix, uri in ontGraph.namespaces():
nsBinds[prefix] = uri
namespace_manager.bind(prefix, uri, override=False)
if options.sparqlEndpoint:
factGraph.store.bind(prefix, uri)
else:
ontGraph = factGraph
NormalFormReduction(ontGraph)
dlp = network.setupDescriptionLogicProgramming(
ontGraph,
addPDSemantics=options.pDSemantics,
constructNetwork=False,
ignoreNegativeStratus=options.negation,
safety=safetyNameMap[options.safety])
ruleSet.formulae.extend(dlp)
if options.output == 'rif' and not options.why:
for rule in ruleSet:
print(rule)
if options.negation:
for nRule in network.negRules:
print(nRule)
elif options.output == 'man-owl':
cGraph = network.closureGraph(factGraph, readOnly=False)
cGraph.namespace_manager = namespace_manager
Individual.factoryGraph = cGraph
if options.classes:
mapping = dict(namespace_manager.namespaces())
for c in options.classes:
pref, uri = c.split(':')
print(Class(URIRef(mapping[pref] + uri)).__repr__(True))
elif options.properties:
mapping = dict(namespace_manager.namespaces())
for p in options.properties:
pref, uri = p.split(':')
print(Property(URIRef(mapping[pref] + uri)))
else:
for p in AllProperties(cGraph):
print(p.identifier, first(p.label))
print(repr(p))
for c in AllClasses(cGraph):
if options.normalize:
if c.isPrimitive():
primAnc = [
sc for sc in c.subClassOf if sc.isPrimitive()
]
if len(primAnc) > 1:
warnings.warn(
"Branches of primitive skeleton taxonomy" +
" should form trees: %s has %s primitive parents: %s"
% (c.qname, len(primAnc), primAnc),
UserWarning, 1)
children = [desc for desc in c.subSumpteeIds()]
for child in children:
for otherChild in [
o for o in children if o is not child
]:
if not otherChild in [
c.identifier
for c in Class(child).disjointWith
]: # and \
warnings.warn(
"Primitive children (of %s) " % (c.qname) + \
"must be mutually disjoint: %s and %s" % (
Class(child).qname, Class(otherChild).qname), UserWarning, 1)
# if not isinstance(c.identifier, BNode):
print(c.__repr__(True))
if not options.why:
# Naive construction of graph
for rule in ruleSet:
network.buildNetworkFromClause(rule)
magicSeeds = []
if options.why:
builtinTemplateGraph = Graph()
if options.builtinTemplates:
builtinTemplateGraph = Graph().parse(options.builtinTemplates,
format='n3')
factGraph.templateMap = \
dict([(pred, template)
for pred, _ignore, template in
builtinTemplateGraph.triples(
(None,
TEMPLATES.filterTemplate,
None))])
goals = []
query = ParseSPARQL(options.why)
network.nsMap['pml'] = PML
network.nsMap['gmp'] = GMP_NS
network.nsMap['owl'] = OWL_NS
nsBinds.update(network.nsMap)
network.nsMap = nsBinds
if not query.prologue:
query.prologue = Prologue(None, [])
query.prologue.prefixBindings.update(nsBinds)
else:
for prefix, nsInst in list(nsBinds.items()):
if prefix not in query.prologue.prefixBindings:
query.prologue.prefixBindings[prefix] = nsInst
print("query.prologue", query.prologue)
print("query.query", query.query)
print("query.query.whereClause", query.query.whereClause)
print("query.query.whereClause.parsedGraphPattern",
query.query.whereClause.parsedGraphPattern)
goals.extend([(s, p, o) for s, p, o, c in ReduceGraphPattern(
query.query.whereClause.parsedGraphPattern,
query.prologue).patterns])
# dPreds=[]# p for s, p, o in goals ]
# print("goals", goals)
magicRuleNo = 0
bottomUpDerivedPreds = []
# topDownDerivedPreds = []
defaultBasePreds = []
defaultDerivedPreds = set()
hybridPredicates = []
mapping = dict(newNsMgr.namespaces())
for edb in options.edb:
pref, uri = edb.split(':')
defaultBasePreds.append(URIRef(mapping[pref] + uri))
noMagic = []
for pred in options.noMagic:
pref, uri = pred.split(':')
noMagic.append(URIRef(mapping[pref] + uri))
if options.ddlGraph:
ddlGraph = Graph().parse(options.ddlGraph, format='n3')
# @TODO: should also get hybrid predicates from DDL graph
defaultDerivedPreds = IdentifyDerivedPredicates(
ddlGraph, Graph(), ruleSet)
else:
for idb in options.idb:
pref, uri = idb.split(':')
defaultDerivedPreds.add(URIRef(mapping[pref] + uri))
defaultDerivedPreds.update(
set([p == RDF.type and o or p for s, p, o in goals]))
for hybrid in options.hybridPredicate:
pref, uri = hybrid.split(':')
hybridPredicates.append(URIRef(mapping[pref] + uri))
if options.method == 'gms':
for goal in goals:
goalSeed = AdornLiteral(goal).makeMagicPred()
print("Magic seed fact (used in bottom-up evaluation)",
goalSeed)
magicSeeds.append(goalSeed.toRDFTuple())
if noMagic:
print("Predicates whose magic sets will not be calculated")
for p in noMagic:
print("\t", factGraph.qname(p))
for rule in MagicSetTransformation(
factGraph,
ruleSet,
goals,
derivedPreds=bottomUpDerivedPreds,
strictCheck=nameMap[options.strictness],
defaultPredicates=(defaultBasePreds, defaultDerivedPreds),
noMagic=noMagic):
magicRuleNo += 1
network.buildNetworkFromClause(rule)
if len(list(ruleSet)):
print("reduction in size of program: %s (%s -> %s clauses)" %
(100 -
(float(magicRuleNo) / float(len(list(ruleSet)))) * 100,
len(list(ruleSet)), magicRuleNo))
start = time.time()
network.feedFactsToAdd(generateTokenSet(magicSeeds))
if not [
rule for rule in factGraph.adornedProgram if len(rule.sip)
]:
warnings.warn(
"Using GMS sideways information strategy with no " +
"information to pass from query. Falling back to " +
"naive method over given facts and rules")
network.feedFactsToAdd(workingMemory)
sTime = time.time() - start
if sTime > 1:
sTimeStr = "%s seconds" % sTime
else:
sTime = sTime * 1000
sTimeStr = "%s milli seconds" % sTime
print("Time to calculate closure on working memory: ", sTimeStr)
if options.output == 'rif':
print("Rules used for bottom-up evaluation")
if network.rules:
for clause in network.rules:
print(clause)
else:
for clause in factGraph.adornedProgram:
print(clause)
if options.output == 'conflict':
network.reportConflictSet()
elif options.method == 'bfp':
topDownDPreds = defaultDerivedPreds
if options.builtinTemplates:
builtinTemplateGraph = Graph().parse(options.builtinTemplates,
format='n3')
builtinDict = dict([
(pred, template) for pred, _ignore, template in
builtinTemplateGraph.triples((None,
TEMPLATES.filterTemplate,
None))
])
else:
builtinDict = None
topDownStore = TopDownSPARQLEntailingStore(
factGraph.store,
factGraph,
idb=ruleSet,
DEBUG=options.debug,
derivedPredicates=topDownDPreds,
templateMap=builtinDict,
nsBindings=network.nsMap,
identifyHybridPredicates=options.hybrid
if options.method == 'bfp' else False,
hybridPredicates=hybridPredicates)
targetGraph = Graph(topDownStore)
for pref, nsUri in list(network.nsMap.items()):
targetGraph.bind(pref, nsUri)
start = time.time()
# queryLiteral = EDBQuery([BuildUnitermFromTuple(goal) for goal in goals],
# targetGraph)
# query = queryLiteral.asSPARQL()
# print("Goal to solve ", query)
sTime = time.time() - start
result = targetGraph.query(options.why, initNs=network.nsMap)
if result.askAnswer:
sTime = time.time() - start
if sTime > 1:
sTimeStr = "%s seconds" % sTime
else:
sTime = sTime * 1000
sTimeStr = "%s milli seconds" % sTime
print("Time to reach answer ground goal answer of %s: %s" %
(result.askAnswer[0], sTimeStr))
else:
for rt in result:
sTime = time.time() - start
if sTime > 1:
sTimeStr = "%s seconds" % sTime
else:
sTime = sTime * 1000
sTimeStr = "%s milli seconds" % sTime
if options.firstAnswer:
break
print(
"Time to reach answer %s via top-down SPARQL sip strategy: %s"
% (rt, sTimeStr))
if options.output == 'conflict' and options.method == 'bfp':
for _network, _goal in topDownStore.queryNetworks:
print(network, _goal)
_network.reportConflictSet(options.debug)
for query in topDownStore.edbQueries:
print(query.asSPARQL())
elif options.method == 'naive':
start = time.time()
network.feedFactsToAdd(workingMemory)
sTime = time.time() - start
if sTime > 1:
sTimeStr = "%s seconds" % sTime
else:
sTime = sTime * 1000
sTimeStr = "%s milli seconds" % sTime
print("Time to calculate closure on working memory: ", sTimeStr)
print(network)
if options.output == 'conflict':
network.reportConflictSet()
for fileN in options.filter:
for rule in HornFromN3(fileN):
network.buildFilterNetworkFromClause(rule)
if options.negation and network.negRules and options.method in [
'both', 'bottomUp'
]:
now = time.time()
rt = network.calculateStratifiedModel(factGraph)
print(
"Time to calculate stratified, stable model (inferred %s facts): %s"
% (rt, time.time() - now))
if options.filter:
print("Applying filter to entailed facts")
network.inferredFacts = network.filteredFacts
if options.closure and options.output in RDF_SERIALIZATION_FORMATS:
cGraph = network.closureGraph(factGraph)
cGraph.namespace_manager = namespace_manager
print(
cGraph.serialize(destination=None,
format=options.output,
base=None))
elif options.output and options.output in RDF_SERIALIZATION_FORMATS:
print(
network.inferredFacts.serialize(destination=None,
format=options.output,
base=None))
from rdflib.graph import Graph
from FuXi.Rete.RuleStore import SetupRuleStore
from FuXi.Rete.Util import generateTokenSet
# from FuXi.DLP.DLNormalization import NormalFormReduction
from FuXi.Horn.HornRules import HornFromN3
from io import StringIO
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
rules = u"""
@prefix owl: <http://www.w3.org/2002/07/owl#> .
{ ?x owl:sameAs ?y } => { ?y owl:sameAs ?x } .
{ ?x owl:sameAs ?y . ?x ?p ?o } => { ?y ?p ?o } .
"""
for rule in HornFromN3(StringIO(rules)):
network.buildNetworkFromClause(rule)
facts = """
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix ex: <http://example.org/> .
@prefix exterms: <http://example.org/terms/> .
ex:foo
a exterms:Something ;
exterms:hasX "blah blah" ;
owl:sameAs ex:bar .
ex:bar
exterms:hasY "yyyy" .
"""
g = Graph()
g.parse(data=facts, format="n3")
from rdflib import Graph
from FuXi.Rete.RuleStore import SetupRuleStore
from FuXi.Rete.Util import generateTokenSet
from FuXi.Horn.HornRules import HornFromN3
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
closureDeltaGraph = Graph()
network.inferredFacts = closureDeltaGraph
for rule in HornFromN3('rules.n3'):
network.buildNetworkFromClause(rule)
factGraph = Graph().parse('facts.n3', format='n3')
network.feedFactsToAdd(generateTokenSet(factGraph))
inferred_facts = closureDeltaGraph.serialize(format='n3')
#write inferred facts to file
inferred = open('inferred.n3', 'w')
inferred.write(inferred_facts)
inferred.close()
from FuXi.Horn.HornRules import HornFromN3
from FuXi.Rete.RuleStore import SetupRuleStore
from FuXi.Rete.Util import generateTokenSet
from rdflib import Graph
rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
closureDeltaGraph = Graph()
network.inferredFacts = closureDeltaGraph
print(network)
for rule in HornFromN3('http://www.agfa.com/w3c/euler/rdfs-rules.n3',
additionalBuiltins=None):
network.buildNetworkFromClause(rule)
print(network)
network.feedFactsToAdd(generateTokenSet(network.inferredFacts))
print(network)