#!/usr/bin/env python """sparql2cwm This is meant to be used with a sparql.n3 based SPARQL parser, to add the query to cwm $Id: sparql2cwm.py,v 1.24 2007/08/06 16:13:56 syosi Exp $ """ from set_importer import Set import uripath from term import Term, CompoundTerm from formula import Formula import diag from why import BecauseOfData from cwm_sparql import SPARQL_NS knownFunctions = {} def value(self, newVal=None): if newVal is not None: self[0] = newVal return self[0] verbose = value.__get__([0]) reason2 = value.__get__([0]) def abbr(prodURI): return prodURI.split('#').pop() class typedThing(unicode): def __new__(cls, val, retType=None, ArgTypes=[], trueOnError=False): ret = unicode.__new__(cls, val) ret.retType = retType ret.argTypes = ArgTypes ret.trueOnError = trueOnError return ret def __call__(self): return unicode(self) + '__' + unicode(self.retType) + '__' + {False:'', True:'lenient__'}[self.trueOnError] + '_'.join(self.argTypes) def getType(ex): if isinstance(ex, typedThing): return ex.retType return None def getTrueOnError(ex): if isinstance(ex, typedThing): return ex.trueOnError return False ORED_AND = typedThing('And', 'boolean', trueOnError=True) AND = typedThing('And', 'boolean') OR = typedThing('Or', 'boolean') ORED_NOT = typedThing('Not', 'Boolean', trueOnError=True) NOT = typedThing('Not', 'boolean') class andExtra(tuple): def __new__(cls, val, extra): ret = tuple.__new__(cls, val) ret.extra = extra return ret def __repr__(self): return repr(tuple(self)) + '+' + repr(self.extra) def getExtra(ex): if isinstance(ex, andExtra): return ex.extra return [] class multimap(dict): """ A class to handle where each element maps to a set of elements It would perhaps be simpler to have used dict.setdefault(), but this has the advantage of merging instead of nesting sets """ class innerSet(Set): pass def __init__(self, olddict={}, **values): self.update(olddict) self.update(values) def __setitem__(self, key, value): if isinstance(value, tuple): raise RuntimeError(key, value) if not key in self: dict.__setitem__(self, key, self.innerSet()) if isinstance(value, self.innerSet): self[key].update(value) elif value: self[key].add(value) def update(self, other={}, **values): if values: self.update(values) for key, val in other.iteritems(): self[key] = val def translate(self, fromkey, tokey): if fromkey not in self: return m = self[fromkey] del self[fromkey] self[tokey] = m def __add__(self, other): k = self.__class__() k.update(self) k.update(other) return k def _fromTuples(cls, iterator): m = cls() for key, val in iterator: m[key] = val return m fromTuples = classmethod(_fromTuples) def makeTriple(subj, pred, obj, safeVersion=False): if safeVersion: store = pred[1].store typeErrorIsTrue = store.newSymbol(SPARQL_NS + '#typeErrorIsTrue') return ('Triple', (('Literal', store.intern(1)), ('predicateList', [(('symbol', typeErrorIsTrue), ('objectList', [('formula', TripleHolder((subj[1], pred[1], obj[1])))]))]))) return ('Triple', (subj, ('predicateList', [(pred, ('objectList', [obj]))]))) def makeSafeVal(val, (subj, pred, obj), safeVersion=False): if safeVersion: store = pred[1].store typeErrorReturner = store.newSymbol(SPARQL_NS + '#typeErrorReturner') replacement = ('Literal', store.intern(1)) if subj==val: subj=replacement return makeTriple(val, ('formula', TripleHolder((subj[1], pred[1], obj[1]))), ('symbol', typeErrorReturner)) if obj==val: obj=replacement return makeTriple(('formula', TripleHolder((subj[1], pred[1], obj[1]))), ('symbol', typeErrorReturner), val) return makeTriple(subj, pred, obj) def makeTripleObjList(subj, pred, obj): return ('Triple', (subj, ('predicateList', [(pred, ('objectList', obj))]))) def normalize(expr): """ The mapping from SPARQL syntax to n3 is decidedly nontrivial at this point, we have done the first step, building an AST that is (relatively) independant of all of the oddities that you get from the grammar Normalize does a couple of top down transforms on the tree. The first is a type determiner; it determines what needs to be coerced to a boolean. The second does boolean logic and pushes ``not''s all the way in. After normalize, the last bottom up step to generate the n3 can be done. """ if verbose(): print expr step1 = Coerce()(expr) return NotNot()(step1) class Coerce(object): def __init__(self): self.k = 0 def __call__(self, expr, coerce=True): try: if verbose(): print ' ' * self.k, expr, coerce self.k = self.k + 1 if expr[0] in ('Var', 'Literal', 'Number', 'String', 'symbol'): ww = self.atom(expr, coerce) elif expr[0] in ('subtract', 'add', 'multiply', 'divide', 'lang', 'datatype'): ww = self.on_math(expr, coerce) elif expr[0] in ('less', 'equal', 'notEqual', 'greater', 'notLess', 'notGreater'): ww = self.on_pred(expr, coerce) else: ww = getattr(self, 'on_' + expr[0])(expr, coerce) self.k = self.k - 1 if verbose(): print ' ' * self.k, '/', ww return ww except AttributeError: raise RuntimeError("COERCE why don't you define a %s function, to call on %s?" % ('on_' + expr[0], `expr`)) def on_function(self, p, coerce): if coerce: return ('BoolVal', self(p, False)) return [p[0], p[1]] + [self(q, False) for q in p[2:]] def on_Or(self, p, coerce): if len(p) == 2: return self(p[1], coerce) return [p[0]] + [self(q, True) for q in p[1:]] def on_And(self, p, coerce): if len(p) == 2: return self(p[1], coerce) return [p[0]] + [self(q, True) for q in p[1:]] def on_BoolVal(self, p, coerce): if coerce: return [p[0], self(p[1], False)] return self(p[1], False) def atom(self, p, coerce): if coerce: return ('BoolVal', p) return p def on_math(self, p, coerce): retVal = [p[0]] + [self(q, False) for q in p[1:]] if coerce: return ('BoolVal', retVal) return retVal def on_Boolean(self, p, coerce): if coerce: return ('BoolVal', p) return p def on_Bound(self, p, coerce): return p def on_Regex(self, p, coerce): return [p[0]] + [self(q, False) for q in p[1:]] def on_pred(self, p, coerce): return [p[0]] + [self(q, False) for q in p[1:]] def on_Not(self, p, coerce): return [p[0], self(p[1], True)] def on_isURI(self, p, coerce): return [p[0], self(p[1], False)] def on_isLiteral(self, p, coerce): return [p[0], self(p[1], False)] def on_isBlank(self, p, coerce): return [p[0], self(p[1], False)] class NotNot(object): """ This class is used to figure out the inverses of all SPARQL boolean tests, and invert all functions """ inverse_operators = {'less' : 'notLess', 'greater' : 'notGreater', 'notLess' : 'less', 'notGreater' : 'greater', 'equal' : 'notEqual', 'notEqual': 'equal', 'isURI' : 'isNotURI', 'isNotURI' : 'isURI', 'isLiteral' : 'isNotLiteral', 'isNotLiteral' : 'isLiteral', 'isBlank' : 'isNotBlank', 'isNotBlank' : 'isBlank', ## 'Not', 'BoolVal', ## 'BoolVal', 'Not', 'Bound': 'notBound' } def __init__(self): self.k = 0 def __call__(self, expr, inv=False, Ored=False): try: if verbose(): print ' ' * self.k, expr, inv self.k = self.k + 1 if not isinstance(expr, (list, tuple)): return expr if expr[0] in self.inverse_operators: ww = self.expr(expr, inv, Ored) elif expr[0] in ('Var', 'Literal', 'Number', 'subtract', 'add', 'datatype', 'multiply', 'divide', 'String', 'symbol', 'function', 'lang'): ww = self.atom(expr, inv, Ored) else: ww = getattr(self, 'on_' + expr[0])(expr, inv, Ored) self.k = self.k - 1 if verbose(): print ' ' * self.k, '/', ww return ww except AttributeError: raise RuntimeError("NOTNOT why don't you define a %s function, to call on %s?" % ('on_' + expr[0], `expr`)) def expr(self, p, inv, ored): if inv: return [typedThing(self.inverse_operators[p[0]], 'boolean', trueOnError=ored)] + [self(q, False, ored) for q in p[1:]] return [typedThing(p[0], trueOnError=ored)] + [self(q, False, ored) for q in p[1:]] def atom(self, p, inv, ored): if ored: p = [typedThing(p[0], getType(p[0]), trueOnError=True)] + [self(q, False, True) for q in p[1:]] if inv and ored: return (ORED_NOT, p) if inv: return (NOT, p) ## if ored: ## return ('typesafe', p) return p def on_Not(self, p, inv, ored): if inv: return self(p[1], False, ored) return self(p[1], True, ored) def on_Regex(self, p, inv, ored): if inv: return [typedThing('notMatches', trueOnError=ored)] + [self(q, False, ored) for q in p[1:]] return [typedThing(p[0], trueOnError=ored)] + [self(q, False, ored) for q in p[1:]] def on_notMatches(self, p, inv): if inv: return [typedThing('Regex', trueOnError=ored)] + [self(q, False, ored) for q in p[1:]] return [typedThing(p[0], trueOnError=ored)] + [self(q, False, ored) for q in p[1:]] def on_Or(self, p, inv, ored): if inv: return [ORED_AND] + [self(q, True, True) for q in p[1:]] return [p[0]] + [self(q, False, False) for q in p[1:]] def on_And(self, p, inv, ored): if inv: return [OR] + [self(q, True, ored) for q in p[1:]] return [p[0]] + [self(q, False, ored) for q in p[1:]] def on_BoolVal(self, p, inv, ored): if inv and ored: return [ORED_NOT, self(p[1], False)] if inv: return [NOT, self(p[1], False)] return [p[0], self(p[1], False)] def on_Boolean_Gen(true, false): def on_Boolean(self, p, inv, ored): if (inv and p[1] != false) or (not inv) and p[1] == false: return (p[0], false) return (p[0], true) return on_Boolean class AST(object): def __init__(self, ast, sink=None): self.ast = ast if sink: self.sink = sink else: self.sink = self def prod(self, thing): return thing[0] def abbr(self, prodURI): return prodURI.split('#').pop() def run(self): self.productions = [] stack = [[self.ast, 0]] while stack: if not isinstance(stack[-1][0][1], (tuple, list)): a = self.onToken(stack[-1][0][0], stack[-1][0][1]) if a: return a stack.pop() elif stack[-1][1] >= len(stack[-1][0]): k = self.onFinish() stack.pop() else: k = stack[-1][1] stack[-1][1] = k + 1 if k == 0: self.onStart(stack[-1][0][0]) else: stack.append([stack[-1][0][k], 0]) return k def onStart(self, prod): if verbose(): if callable(prod): print (' ' * len(self.productions)) + prod() else: print (' ' * len(self.productions)) + `prod` #if callable(prod): # prod = prod() self.productions.append([prod]) def onFinish(self): k = self.productions.pop() prodName = self.abbr(k[0]) prod = self.sink.prod(k) if self.productions: self.productions[-1].append(prod) if verbose(): print (' ' * len(self.productions)) + '/' + prodName + ': ' + `prod` return prod def onToken(self, prod, tok): k = self.sink.prod((prod, tok)) try: self.productions[-1].append(k) except IndexError: return k if verbose(): print (' ' * len(self.productions)) + `(prod, tok)` class productionHandler(object): def prod(self, production): if hasattr(self, 'on_' + abbr(production[0])): try: return getattr(self, 'on_' + abbr(production[0]))(production) except: print production raise if True: # len(production) > 1: raise RuntimeError("why don't you define a %s function, to call on %s?" % ('on_' + abbr(production[0]), `production`)) return production class TripleHolder(tuple): def __new__(cls, *args, **keywords): self = tuple.__new__(cls, *args, **keywords) if len(self) != 3: raise TypeError return self class FilterExpr(productionHandler): def __init__(self, store, parent): self.store = store self.parent = parent self.bnode = parent.new_bnode self.string = store.newSymbol('http://www.w3.org/2000/10/swap/string') self.anything = self.parent.sparql self.math = self.parent.math self.log = self.parent.store.newSymbol('http://www.w3.org/2000/10/swap/log') def on_function(self, p): args = [] extra = [] keepGoing = getTrueOnError(p[0]) rawArgs = p[2:] for rawArg in rawArgs: if not isinstance(rawArg, tuple): return ['Error'] extra.extend(getExtra(rawArg)) args.append(tuple(rawArg)) if p[1] not in knownFunctions: raise NotImplementedError('''I don't support the ``%s'' function''' % p[1]) try: node, triples = knownFunctions[p[1]](self, keepGoing, *args) return andExtra(node, triples + extra) except TypeError: # raise return ['Error'] def typeConvert(self, keepGoing, uri, val): retVal = self.bnode() return (retVal, [makeSafeVal(retVal, (('List', [val[1], self.store.newSymbol(uri)]), ('symbol', self.anything['dtLit']), retVal), safeVersion=keepGoing)]) def on_BoolVal(self, p): extra = getExtra(p[1]) val = tuple(p[1]) return [makeTriple(val, ('symbol', self.anything['truthValue']), ('symbol', self.parent.true), safeVersion=getTrueOnError(p[0]))] + extra def on_Not(self, p): extra = getExtra(p[1]) val = tuple(p[1]) if val == ('Error',): return ['Error'] return [makeTriple(val, ('symbol', self.anything['truthValue']), ('symbol', self.parent.false), safeVersion=getTrueOnError(p[0]))] + extra def on_And(self, p): vals = [] succeedAnyway = getTrueOnError(p[0]) things = p[1:] for thing in things: if thing == ['Error']: if succeedAnyway: continue return ['Error'] vals.extend(thing) return vals def on_Or(self, p): p = p[1:] returns = [] for val in p: if val != ['Error']: returns.extend(self.parent.on_GroupGraphPattern([None, None, val, None], True)) return [('union', returns)] def on_Regex(self, p): if str(p[3][1]): raise NotImplementedError('I don\'t know how to deal with flags. The flag is: %r' % p[3][1]) extra = getExtra(p[1]) + getExtra(p[2]) string = tuple(p[1]) regex = tuple(p[2]) return [makeTriple(string, ('symbol', self.string['matches']), regex, safeVersion=getTrueOnError(p[0]))] + extra def compare(self, p, op): if not isinstance(p[1], tuple) or not isinstance(p[2], tuple): return ['Error'] extra = getExtra(p[1]) + getExtra(p[2]) op1 = tuple(p[1]) op2 = tuple(p[2]) return [makeTriple(op1, ('symbol', op), op2, safeVersion=getTrueOnError(p[0]))] + extra def on_less(self, p): return self.compare(p, self.anything['lessThan']) def on_notLess(self, p): return self.compare(p, self.anything['notLessThan']) def on_equal(self, p): return self.compare(p, self.anything['equals']) def on_notEqual(self, p): return self.compare(p, self.anything['notEquals']) def on_greater(self, p): return self.compare(p, self.anything['greaterThan']) def on_notGreater(self, p): return self.compare(p, self.anything['notGreaterThan']) def arithmetic(self, p, op): if not isinstance(p[1], tuple) or not isinstance(p[2], tuple): return ['Error'] extra = getExtra(p[1]) + getExtra(p[2]) op1 = tuple(p[1]) op2 = tuple(p[2]) retVal = self.bnode() triple = makeSafeVal(retVal, (('List', [op1[1], op2[1]]), ('symbol', op), retVal), safeVersion=getTrueOnError(p[0])) return andExtra(retVal, [triple] + extra) def on_subtract(self, p): return self.arithmetic(p, self.math['difference']) def on_add(self, p): return self.arithmetic(p, self.math['sum']) def on_multiply(self, p): return self.arithmetic(p, self.math['product']) def on_divide(self, p): return self.arithmetic(p, self.math['quotient']) def on_Var(self, p): return p def on_symbol(self, p): return p def on_Literal(self, p): return p def on_Boolean(self, p): return p def on_Number(self, p): return p def on_String(self, p): return p def on_funcName(self, p): return p[1] def on_notBound(self, var): var = ('Literal', self.store.newLiteral(var[1][1].uriref())) return [makeTriple(self.bnode(), ('symbol', self.parent.sparql['notBound']), var)] def on_Bound(self, var): var = ('Literal', self.store.newLiteral(var[1][1].uriref())) return [makeTriple(self.bnode(), ('symbol', self.parent.sparql['bound']), var)] def on_isURI(self, p): return [makeTriple(p[1], ('symbol', self.log['rawType']), ('symbol', self.parent.store.Other), safeVersion=getTrueOnError(p[0]))] def on_isNotURI(self, p): k = self.bnode() return [makeTriple(p[1], ('symbol', self.log['rawType']), k, safeVersion=getTrueOnError(p[0])), makeTriple(k, ('symbol', self.log['notEqualTo']), ('symbol', self.parent.store.Other))] def on_lang(self, p): if not isinstance(p[1], tuple): return ['Error'] extra = getExtra(p[1]) op1 = tuple(p[1]) retVal = self.bnode() meaningLess = self.bnode() triple = makeSafeVal(retVal, (('List', [meaningLess[1], retVal[1]]), ('symbol', self.anything['langLit']), p[1]), safeVersion=getTrueOnError(p[0])) return andExtra(retVal, [triple] + extra) def on_datatype(self, p): if not isinstance(p[1], tuple): return ['Error'] extra = getExtra(p[1]) op1 = tuple(p[1]) retVal = self.bnode() meaningLess = self.bnode() triple = makeSafeVal(retVal, (('List', [meaningLess[1], retVal[1]]), ('symbol', self.anything['dtLit']), p[1]), safeVersion=getTrueOnError(p[0])) return andExtra(retVal, [triple] + extra) class FromSparql(productionHandler): def __init__(self, store, formula=None, ve=0, why=None): verbose(ve) self.store = store if formula is None: self.formula = store.newFormula() else: self.formula = formula self.prefixes = {} self.vars = {} self.base = 'http://yosi.us/sparql#' self.sparql = store.newSymbol(SPARQL_NS) self.xsd = store.newSymbol('http://www.w3.org/2001/XMLSchema') self.math = store.newSymbol('http://www.w3.org/2000/10/swap/math') self.numTypes = Set([self.xsd[k] for k in ['unsignedShort', 'short', 'nonPositiveInteger', 'decimal', 'unsignedInt', 'long', 'nonNegativeInteger', 'int', 'unsignedByte', 'positiveInteger', 'integer', 'byte', 'negativeInteger', 'unsignedLong']]) self.true = store.newLiteral('true', dt=self.xsd['boolean']) self.false = store.newLiteral('false', dt=self.xsd['boolean']) self.anonymous_counter = 0 self.uribase = uripath.base() self.dataSets = None NotNot.on_Boolean = on_Boolean_Gen(self.true, self.false) self._reason = why # Why the parser w _reason2 = None # Why these triples if diag.tracking: _reason2 = BecauseOfData(store.newSymbol(self.base), because=self._reason) reason2(_reason2) self.anNodes = {} def anonymize(self, formula, uri = None): if uri is not None: if isinstance(uri, TripleHolder): f = formula.newFormula() f.add(*[self.anonymize(formula, k) for k in uri]) return f.close() if isinstance(uri, list): return formula.newList([self.anonymize(formula, k) for k in uri]) if isinstance(uri, Formula): return uri.close() if isinstance(uri, Term): return uri try: if uri in self.anNodes: return self.anNodes[uri] except: print uri print 'uri = ', uri raise self.anNodes[uri] = formula.newBlankNode(why=reason2()) return self.anNodes[uri] return formula.newBlankNode(why=reason2()) def new_bnode(self): self.anonymous_counter += 1 return ('anonymous', '_:%s' % str(self.anonymous_counter)) def absolutize(self, uri): return uripath.join(self.uribase, uri) def on_Query(self, p): return self.formula def on_BaseDecl(self, p): self.uribase = p[2][1][1:-1] def makePatterns(self, f, node, patterns): sparql = self.sparql knowledge_base_f = f.newFormula() if not self.dataSets: knowledge_base = f.newBlankNode() f.add(self.uribase, sparql['data'], knowledge_base, why=reason2()) else: knowledge_base = knowledge_base_f.newBlankNode(why=reason2()) sources = self.store.nil #raise RuntimeError(self.dataSets) for uri in self.dataSets: stuff = knowledge_base_f.newBlankNode(why=reason2()) uri2 = self.anonymize(knowledge_base_f,uri[1]) knowledge_base_f.add(uri2, self.store.semantics, stuff, why=reason2()) sources = sources.prepend(stuff) knowledge_base_f.add(sources, self.store.newSymbol('http://www.w3.org/2000/10/swap/log#conjunction'), knowledge_base) for pattern in patterns: tail = f.newFormula() tail.loadFormulaWithSubstitution(pattern[1], why=reason2()) tail.loadFormulaWithSubstitution(knowledge_base_f, why=reason2()) includedStuff = pattern[4] notIncludedStuff = pattern[5] for nodeName, graphIntersection in includedStuff.iteritems(): if not graphIntersection: continue graph = f.newFormula() for subGraph in graphIntersection: graph.loadFormulaWithSubstitution(subGraph, why=reason2()) graph = graph.close() if nodeName is not None: nameNode = self.anonymize(tail, nodeName[1]) semantics = tail.newBlankNode(why=reason2()) tail.add(nameNode, self.store.semantics, semantics, why=reason2()) else: semantics = knowledge_base tail.add(semantics, self.store.includes, graph, why=reason2()) includedVars = Set(self.vars.values()) excludedVars = includedVars.difference(tail.occurringIn(includedVars)) for nodeName, graphIntersection in notIncludedStuff.iteritems(): if not graphIntersection: continue ## graph = f.newFormula() for subGraph in graphIntersection: ## graph.loadFormulaWithSubstitution(subGraph) ## graph = graph.close() if nodeName is not None: nameNode = self.anonymize(tail, nodeName[1]) semantics = tail.newBlankNode(why=reason2()) tail.add(nameNode, self.store.semantics, semantics, why=reason2()) else: semantics = knowledge_base excludedMap = {} bNodedSubGraph = subGraph.newFormula() for v in excludedVars: excludedMap[v] = bNodedSubGraph.newBlankNode() bNodedSubGraph.loadFormulaWithSubstitution(subGraph, excludedMap) tail.add(semantics, self.store.smartNotIncludes, bNodedSubGraph.close(), why=reason2()) f.add(node, sparql['where'], tail.close(), why=reason2()) ## for parent in pattern[2]: ## f.add(pattern[1], sparql['andNot'], parent) def on_SelectQuery(self, p): sparql = self.sparql store = self.store f = self.formula ## for v in self.vars: ## f.declareUniversal(v) q = f.newBlankNode() f.add(q, store.type, sparql['SelectQuery'], why=reason2()) variable_results = store.newFormula() for v in p[3][1]: # variable_results.add(v, store.type, sparql['Binding']) variable_results.add(v, sparql['bound'], abbr(v.uriref()), why=reason2()) f.add(q, sparql['select'], variable_results.close(), why=reason2()) if p[2]: f.add(q, store.type, sparql['Distinct']) self.makePatterns(f, q, p[5]) f3 = RulesMaker(self.sparql).implications(q, f, variable_results) for triple in f3.statementsMatching(pred=sparql['implies']): f4 = f3.newFormula() f4.add(triple.object(), store.type, sparql['Result'], why=reason2()) f.add(triple.subject(), store.implies, f4.close(), why=reason2()) #TODO: I'm missing sorting and datasets if p[6] and p[6] != (None, None, None): raise NotImplementedError('Cwm does not support output modifiers yet') sort, limit, offset = p[6] if sort: l = self.store.newList(sort) f.add(q, sparql['sort'], l) if limit: f.add(q, sparql['limit'], limit) if offset: f.add(q, sparql['offset'], offset) # raise RuntimeError(`p[6]`) return None def on_ConstructQuery(self, p): sparql = self.sparql store = self.store f = self.formula ## for v in self.vars: ## f.declareUniversal(v) q = f.newBlankNode() f.add(q, store.type, sparql['ConstructQuery']) f.add(q, sparql['construct'], p[2]) knowledge_base = f.newFormula() self.makePatterns(f, q, p[4]) f3 = RulesMaker(self.sparql).implications(q, f, p[2]) for triple in f3.statementsMatching(pred=sparql['implies']): f.add(triple.subject(), store.implies, triple.object()) return None def on_AskQuery(self, p): sparql = self.sparql store = self.store f = self.formula ## for v in self.vars: ## f.declareUniversal(v) q = f.newBlankNode() f.add(q, store.type, sparql['AskQuery']) only_result = store.newFormula() only_result.add(q, store.type, sparql['Success']) only_result = only_result.close() self.makePatterns(f, q, p[3]) f3 = RulesMaker(self.sparql).implications(q, f, only_result) for triple in f3.statementsMatching(pred=sparql['implies']): f.add(triple.subject(), store.implies, only_result) return None def on_WhereClause(self, p): stuff2 = p[2] stuff = [] # raise RuntimeError(`p`) for k in stuff2: append = True positiveTriples = None freeVariables = None included = k[5]+k[3]+{None: k[1]} notIncluded = k[6] ## print '+++++++++++++' ## print 'included=', included ## print 'notIncluded=', notIncluded for pred, obj in k[4]: if positiveTriples is None: positiveTriples = self.store.newFormula() for formSet in included.values(): for form in formSet: positiveTriples.loadFormulaWithSubstitution(form) positiveTriples = positiveTriples.close() freeVariables = Set([x.uriref() for x in positiveTriples.freeVariables()]) if pred is self.sparql['bound']: variable = unicode(obj) if variable not in freeVariables: append = False elif pred is self.sparql['notBound']: ##@@@ This is broken!! variable = unicode(obj) if variable in freeVariables: append = False if append: stuff.append((k[0], k[2], k[3], k[4], included, notIncluded)) ## ## Formula.doesNodeAppear = realNodeAppear # raise RuntimeError(stuff) return stuff def on_SolutionModifier(self, p): if len(p) == 1: return None return tuple(p[1:]) def on__QOrderClause_E_Opt(self, p): if len(p) == 1: return None return p[1] def on__QLimitClause_E_Opt(self, p): if len(p) == 1: return None return p[1] def on__QOffsetClause_E_Opt(self, p): if len(p) == 1: return None return p[1] def on__QBaseDecl_E_Opt(self, p): return None def on_PrefixDecl(self, p): self.prefixes[p[2][1][:-1]] = self.absolutize(p[3][1][1:-1]) self.store.bind(p[2][1][:-1],self.absolutize(p[3][1][1:-1])) return None def on__QDISTINCT_E_Opt(self, p): if len(p) == 1: return None return None raise NotImplementedError(`p`) def on_Var(self, p): uri = self.base + p[1][1][1:] if uri not in self.vars: self.vars[uri] = self.formula.newUniversal(uri) ## self.vars.add(var) return ('Var', self.vars[uri]) def on__QVar_E_Plus(self, p): if len(p) == 1: return [] return p[2] + [p[1]] def on__O_QVar_E_Plus_Or__QTIMES_E__C(self, p): if len(p) == 3: varList = [x[1] for x in p[2] + [p[1]]] else: class ___(object): def __iter__(s): return iter(self.vars.values()) varList = ___() return ('SelectVars', varList) def on__QDatasetClause_E_Star(self, p): return None def on_VarOrTerm(self, p): return p[1] def on_QName(self, p): qn = p[1][1].split(':') if len(qn) != 2: raise RuntimeError return ('QuotedIRIref', '<' + self.prefixes[qn[0]] + qn[1] + '>') def on_IRIref(self, p): return ('symbol', self.store.newSymbol(self.absolutize(p[1][1][1:-1]))) def on_VarOrBlankNodeOrIRIref(self, p): return p[1] def on_String(self, p): return ('str', unEscape(p[1][1])) def on_Verb(self, p): if abbr(p[1][0]) == 'IT_a': return ('symbol', self.store.type) return p[1] def on__Q_O_QLANGTAG_E__Or__QDTYPE_E____QIRIref_E__C_E_Opt(self, p): if len(p) == 1: return (None, None) return p[1] def on_RDFLiteral(self, p): return ('Literal', self.store.newLiteral(p[1][1], dt=p[2][0], lang=p[2][1])) def on_NumericLiteral(self, p): if abbr(p[1][0]) == 'INTEGER': return ('Literal', self.store.newLiteral(`int(p[1][1])`, dt=self.xsd['integer'], lang=None)) if abbr(p[1][0]) == 'FLOATING_POINT': return ('Literal', self.store.newLiteral(`float(p[1][1])`, dt=self.xsd['double'], lang=None)) raise RuntimeError(`p`) def on_RDFTerm(self, p): return p[1] def on_GraphTerm(self, p): return p[1] def on_Object(self, p): if p[1][0] != 'andExtra': return ('andExtra', p[1], []) return p[1] def on__Q_O_QCOMMA_E____QObjectList_E__C_E_Opt(self, p): if len(p) == 1: return ('andExtra', [], []) return p[1] def on_ObjectList(self, p): extras = p[2][2] + p[1][2] objects = p[2][1] + [p[1][1]] return ('andExtra', ('objectList', [k for k in objects]), extras) def on__Q_O_QSEMI_E____QPropertyList_E__C_E_Opt(self, p): if len(p) == 1: return ('andExtra', ('predicateList', []), []) return p[1] def on_PropertyListNotEmpty(self, p): extra = p[2][2] + p[3][2] pred = (p[1], p[2][1]) preds = p[3][1][1] + [pred] return ('andExtra', ('predicateList', [k for k in preds]), extra) def on_Triples1(self, p): if abbr(p[1][0]) == 'GT_LBRACKET': return p[2] if abbr(p[1][0]) == 'GT_LPAREN': return p[2] extra = p[2][2] return [('Triple', (p[1], p[2][1]))] + extra def on_Triples2(self, p): if len(p) == 4: predList = ('predicateList', p[1][1][1] + p[3][1][1]) extra = p[1][2] + p[3][2] else: predList = p[2][1] extra = p[2][2] return [('Triple', (self.new_bnode(), predList))] + extra def on_Triples3(self, p): store = self.store if len(p) == 3: return [('Triple', (('symbol', store.nil), p[2][1]))] + p[2][2] extra = p[1][2] + p[2][2] + p[4][2] nodes = [p[1][1]] + p[2][1] pred = p[4][1] realPred = pred[1] if realPred == []: realPred.append((('symbol', self.sparql['lamePred']), ('objectList', [('symbol', self.sparql['LameObject'])]))) List = ('List', [k[1] for k in nodes]) return [('Triple', (List, pred))] + extra def on_GraphPatternListTail(self, p): if len(p) == 1: return [] return p[1] def on__O_QTriples1_E____QGraphPatternListTail_E__Or__QGraphPatternNotTriples_E____QGraphPatternNotTriplesTail_E__C(self, p): return p[2] + p[1] def on__Q_O_QTriples1_E____QGraphPatternListTail_E__Or__QGraphPatternNotTriples_E____QGraphPatternNotTriplesTail_E__C_E_Opt(self, p): if len(p) == 1: return [] return p[1] def on_GraphPatternList(self, p): if len(p) == 1: return [] if len(p) == 2: return p[1] return p[1] + p[2] def on__O_QDot_E____QGraphPatternList_E__C(self, p): return p[2] def on__Q_O_QDot_E____QGraphPatternList_E__C_E_Opt(self, p): if len(p) == 1: return [] return p[1] def on_GroupGraphPattern(self, p, fromFilter = False): store = self.store triples = p[2] options = [] alternates = [] parents = multimap() bounds = [] subGraphs = [] f = self.store.newFormula() for triple in triples: if triple == 'Error': return [] try: if triple[0] == 'union': alternates.append([k[1:] for k in triple[1]]) continue if triple[0] == 'SubGraph': subGraphs.append(triple[1:]) continue rest1 = triple[1] subject = rest1[0] predicateList = rest1[1][1] for rest2 in predicateList: predicate = rest2[0] objectList = rest2[1][1] for object in objectList: try: subj = self.anonymize(f, subject[1]) pred = self.anonymize(f, predicate[1]) if pred is self.sparql['OPTIONAL']: options.append(object) else: obj = self.anonymize(f, object[1]) if pred is self.sparql['bound'] or pred is self.sparql['notBound']: bounds.append((pred, obj)) #print alternates, object[1], isinstance(object[1], Term), self.anonymize(f, object[1]) ## elif isinstance(obj, Formula): ## options.extend(object[2]) ## f.add(subj, pred, obj) else: f.add(subj, pred, obj, why=reason2()) except: print '================' print 'subject= ', subject print 'predicate= ', predicate print 'pred= ', pred is self.sparql['OPTIONAL'], id(pred), id(self.sparql['OPTIONAL']) print 'object= ', object raise except: print 'triples=',triples print 'triple=',triple raise f = f.close() if fromFilter: retVal = [('formula', self.store.newFormula(), f, parents, bounds, multimap(), multimap())] else: retVal = [('formula', f, self.store.newFormula(), parents, bounds, multimap(), multimap())] for nodeName, subGraphList in subGraphs: oldRetVal = retVal retVal = [] for _, f, filters, p, b, i, nI in oldRetVal: node = self.anonymize(f, nodeName[1]) for __, subF, filters2, p2, b2, i2, nI2 in subGraphList: #@@@@@ What do I do with b2? newF = f.newFormula() newF.loadFormulaWithSubstitution(f) newFilters = f.newFormula() newFilters.loadFormulaWithSubstitution(filters) newFilters.loadFormulaWithSubstitution(filters2) i2.translate(None, nodeName) nI2.translate(None, nodeName) p2.translate(None, nodeName) retVal.append(('formula', newF.close(), newFilters.close(), p+p2, b+b2, i + i2 + {nodeName: subF}, nI + nI2)) for alternate in alternates: oldRetVal = retVal retVal = [] for formula1, filters1, parents1, bounds1, include1, notInclude1 in alternate: for ss, formula2, filters2, parents2, bounds2, include2, notInclude2 in oldRetVal: f = self.store.newFormula() if formula1: f.loadFormulaWithSubstitution(formula1) f.loadFormulaWithSubstitution(formula2) newFilters = f.newFormula() newFilters.loadFormulaWithSubstitution(filters1) newFilters.loadFormulaWithSubstitution(filters2) retVal.append(('formula', f.close(), newFilters.close(), parents1 + parents2, bounds1 + bounds2, include1 + include2, notInclude1 + notInclude2)) for alternate in options: oldRetVal = retVal retVal = [] for ss, formula1, filters1, parents1, bounds1, i1, nI1 in alternate: for ss, formula2, filters2, parents2, bounds2, i2, nI2 in oldRetVal: f1 = self.store.newFormula() f1.loadFormulaWithSubstitution(formula1, why=reason2()) f1.loadFormulaWithSubstitution(formula2, why=reason2()) f1 = f1.close() f2 = self.store.newFormula() f2.loadFormulaWithSubstitution(formula2, why=reason2()) f3 = formula1.newFormula() f3.loadFormulaWithSubstitution(formula1, why=reason2()) for document in i1: semantics = f3.newBlankNode() f3.add(document[1], self.store.semantics, semantics) totalFormula = f3.newFormula() for f4 in i1[document]: totalFormula.loadFormulaWithSubstitution(f4, why=reason2()) f3.add(semantics, self.store.includes, totalFormula.close()) f3.loadFormulaWithSubstitution(filters1, why=reason2()) f3 = f3.close() newFilters1 = f1.newFormula() newFilters1.loadFormulaWithSubstitution(filters1, why=reason2()) newFilters1.loadFormulaWithSubstitution(filters2, why=reason2()) newFilters2 = f2.newFormula() newFilters2.loadFormulaWithSubstitution(filters2, why=reason2()) retVal.append(('formula', formula2.close(), newFilters1.close(), parents1 + parents2+{None:formula1}, bounds1 + bounds2, i1+i2, nI1+nI2)) retVal.append(('formula', formula2.close(), newFilters2.close(), parents2, bounds1 + bounds2, i2, nI2+{None:f3})) return retVal ## ## if len(p) == 2: ## p.append([]) ## if p[1][0][0] == 'Triple': ## p[2] = p[1][1:] + p[2] ## p[1] = p[1][0] ## if p[1][0] == 'Triple': ## ## ## elif p[1][0][0] == 'formula': ## if p[2]: ## raise RuntimeError(`p`) ## graphs = p[1] ## return graphs ## else: ## raise RuntimeError(`p`) def on__QPropertyListNotEmpty_E_Opt(self, p): if len(p) == 1: return ('andExtra', ('predicateList', []), []) return p[1] def on_PropertyList(self, p): return p[1] def on_NamelessBlank(self, p): return self.new_bnode() def on_BlankNode(self, p): return ('anonymous', p[1][1]) def on_BlankNodePropertyList(self, p): extra = p[2][2] preds = p[2][1] anon = self.new_bnode() extra.append(('Triple', (anon, preds))) return ('andExtra', anon, extra) def on_TriplesNode(self, p): return p[1] def on__O_QSEMI_E____QPropertyList_E__C(self, p): return p[2] def on_GraphNode(self, p): if p[1][0] != 'andExtra': return ('andExtra', p[1], []) return p[1] def on__QGraphNode_E_Plus(self, p): return self.on__QGraphNode_E_Star(p) def on__QGraphNode_E_Star(self, p): if len(p) == 1: return ('andExtra', [], []) nodes = [p[1][1]] + p[2][1] extra = p[1][2] + p[2][2] return ('andExtra', nodes, extra) def on_Collection(self, p): extra = p[2][2] nodes = p[2][1] List = ('List', [k[1] for k in nodes]) return ('andExtra', List, extra) def on_GraphPatternNotTriplesList(self, p): return p[1] + p[2] ### End Triples Stuff #GRAPH def on_GraphGraphPattern(self, p): return [('SubGraph', p[2], p[3])] ## semantics = self.new_bnode() ## return [makeTriple(p[2], ('symbol', self.store.semantics), semantics), ## ('SubGraph', semantics, p[3]) ### makeTripleObjList(semantics, ('symbol', self.store.includes), p[3]) ## ] #OPTIONAL def on_GraphPatternNotTriples(self, p): return p[1] def on_GraphPatternNotTriplesTail(self, p): if len(p) == 1: return [] return p[1] def on__O_QDot_E_Opt___QGraphPatternList_E__C(self, p): return p[2] def on_OptionalGraphPattern(self, p): return [makeTriple(self.new_bnode(), ('symbol', self.sparql['OPTIONAL']), p[2])] #UNION def on__O_QUNION_E____QGroupGraphPattern_E__C(self, p): return p[2] def on__Q_O_QUNION_E____QGroupGraphPattern_E__C_E_Star(self, p): if len(p) == 1: return [] return p[1] + p[2] def on_GroupOrUnionGraphPattern(self, p): return [('union', p[1] + p[2])] #FILTER def on_PrimaryExpression(self, p): return p[1] def on_UnaryExpression(self, p): if len(p) == 2: ## if getType(p[1][0]) != 'boolean': ## return (typedThing('BoolVal', 'boolean'), p[1]) return p[1] if abbr(p[1][0]) == 'GT_NOT': return (typedThing('Not', 'boolean'), p[2]) raise RuntimeError(`p`) def on__Q_O_QTIMES_E____QUnaryExpression_E__Or__QDIVIDE_E____QUnaryExpression_E__C_E_Star(self, p): if len(p) == 1: return [] if not p[2]: return p[1] return (p[1][0], (p[2][0], p[1][1], p[2][1])) def on_MultiplicativeExpression(self, p): if p[2] == []: return p[1] return (p[2][0], p[1], p[2][1]) def on__Q_O_QPLUS_E____QMultiplicativeExpression_E__Or__QMINUS_E____QMultiplicativeExpression_E__C_E_Star(self, p): if len(p) == 1: return [] if not p[2]: return p[1] return (p[1][0], (p[2][0], p[1][1], p[2][1])) def on_AdditiveExpression(self, p): if p[2] == []: return p[1] return (p[2][0], p[1], p[2][1]) def on_NumericExpression(self, p): return p[1] def on__Q_O_QEQUAL_E____QNumericExpression_E__Or__QNEQUAL_E____QNumericExpression_E__Or__QLT_E____QNumericExpression_E__Or__QGT_E____QNumericExpression_E__Or__QLE_E____QNumericExpression_E__Or__QGE_E____QNumericExpression_E__C_E_Opt(self, p): if len(p) == 1: return None return p[1] def on_RelationalExpression(self, p): if p[2] is None: return p[1] ## if p[2][0] != 'less': ## raise RuntimeError(p[2], getType(p[2][1][0])) if p[2][0] == 'equal': t1, t2 = getType(p[1][0]), getType(p[2][1][0]) if t1 == 'boolean' or t2 == 'boolean': return (OR, (AND, p[1], p[2][1]), (AND, (NOT, p[1]), (NOT, p[2][1]))) if p[2][0] == 'notEqual': t1, t2 = getType(p[1]), getType(p[2][1]) if t1 == 'boolean' or t2 == 'boolean': return (OR, (AND, (NOT, p[1]), p[2][1]), (AND, p[1], (NOT, p[2][1]))) return (typedThing(p[2][0], 'boolean'), p[1], p[2][1]) def on_ValueLogical(self, p): return p[1] def on__Q_O_QAND_E____QValueLogical_E__C_E_Star(self, p): if len(p) == 1: return [] return [p[1]] + p[2] def on_ConditionalAndExpression(self, p): if p[2]: return [AND, p[1]] + p[2] return p[1] def on__Q_O_QOR_E____QConditionalAndExpression_E__C_E_Star(self, p): if len(p) == 1: return [] return [p[1]] + p[2] def on_ConditionalOrExpression(self, p): if p[2]: return [OR, p[1]] + p[2] return p[1] def on_Expression(self, p): return p[1] def on_BrackettedExpression(self, p): return p[2] def on__O_QBrackettedExpression_E__Or__QCallExpression_E__C(self, p): """see normalize for an explanation of what we are doing""" return normalize(p[1]) def on_Constraint(self, p): val = AST(p[2], FilterExpr(self.store, self)).run() return [('union', self.on_GroupGraphPattern([None, None, val, None], True))] #useless def on__QPrefixDecl_E_Star(self, p): return None def on_Prolog(self, p): return None def on__QWHERE_E_Opt(self, p): return None def on__O_QSelectQuery_E__Or__QConstructQuery_E__Or__QDescribeQuery_E__Or__QAskQuery_E__C(self, p): return None def on__QDot_E_Opt(self, p): return None ### AutoGenerated def on_OffsetClause(self, p): return self.on_NumericLiteral(p[1:])[1] def on_DescribeQuery(self, p): raise RuntimeError(`p`) def on__QVarOrIRIref_E_Plus(self, p): raise RuntimeError(`p`) def on__O_QVarOrIRIref_E_Plus_Or__QTIMES_E__C(self, p): raise RuntimeError(`p`) def on__QWhereClause_E_Opt(self, p): raise RuntimeError(`p`) def on_DatasetClause(self, p): return None def on__O_QDefaultGraphClause_E__Or__QNamedGraphClause_E__C(self, p): return None def on_DefaultGraphClause(self, p): if not self.dataSets: self.dataSets = [] self.dataSets.append(p[1]) return None def on_NamedGraphClause(self, p): return None def on_SourceSelector(self, p): return p[1] def on_OrderClause(self, p): clauses = [p[3]] + p[4] return clauses raise RuntimeError(`p`) def on__QOrderCondition_E_Plus(self, p): if len(p) == 1: return [] return [p[1]] + p[2] raise RuntimeError(`p`) def on_OrderCondition(self, p): def listize(thing): if len(thing) == 2 and isinstance(thing[1], Term): return thing[1] if thing[0] == 'function': return self.store.newList([self.store.newSymbol(thing[1][1])] + [listize(x) for x in thing[2:]]) return self.store.newList([self.store.newLiteral(thing[0])] + [listize(x) for x in thing[1:]]) return listize(p[1]) raise RuntimeError(`p`) def on__O_QASC_E__Or__QDESC_E__C(self, p): return p[1][1] def on__O_QASC_E__Or__QDESC_E____QBrackettedExpression_E__C(self, p): return p[1:] def on__O_QFunctionCall_E__Or__QVar_E__Or__QBrackettedExpression_E__C(self, p): return p[1] def on_LimitClause(self, p): return self.on_NumericLiteral(p[1:])[1] def on_ConstructTemplate(self, p): return self.on_GroupGraphPattern(p)[0][1] def on__QTriples_E_Opt(self, p): if len(p) == 1: return [] return p[1] def on_Triples(self, p): return p[1] + p[2] def on__QTriples_E_Opt(self, p): if len(p) == 1: return [] return p[1] def on__O_QDot_E____QTriples_E_Opt_C(self, p): return p[2] def on__Q_O_QDot_E____QTriples_E_Opt_C_E_Opt(self, p): if len(p) == 1: return [] return p[1] def on__O_QCOMMA_E____QObjectList_E__C(self, p): #raise RuntimeError(`p`) return (p[2][0], p[2][1][1], p[2][2]) def on_VarOrIRIref(self, p): raise RuntimeError(`p`) def on__O_QOR_E____QConditionalAndExpression_E__C(self, p): return p[2] def on__O_QAND_E____QValueLogical_E__C(self, p): return (AND, p[2]) def on__O_QEQUAL_E____QNumericExpression_E__Or__QNEQUAL_E____QNumericExpression_E__Or__QLT_E____QNumericExpression_E__Or__QGT_E____QNumericExpression_E__Or__QLE_E____QNumericExpression_E__Or__QGE_E____QNumericExpression_E__C(self, p): op = p[1][1] opTable = { '>': 'greater', '<': 'less', '>=': 'notLess', '<=': 'notGreater', '=': 'equal', '!=': 'notEqual'} return (opTable[op], p[2]) def on__O_QPLUS_E____QMultiplicativeExpression_E__Or__QMINUS_E____QMultiplicativeExpression_E__C(self, p): return ({'+': typedThing('add', 'number'), '-': typedThing('subtract', 'number')}[p[1][1]], p[2]) def on__O_QTIMES_E____QUnaryExpression_E__Or__QDIVIDE_E____QUnaryExpression_E__C(self, p): return ({'*': typedThing('multiply', 'number'), '/': typedThing('divide', 'number')}[p[1][1]], p[2]) def on_CallExpression(self, p): return p[1] def on_BuiltinCallExpression(self, p): if len(p) == 2: return p[1] funcName = abbr(p[1][0]) if funcName == 'IT_BOUND': return (typedThing('Bound', 'boolean', ['variable']), p[3]) if funcName == 'IT_isURI': return (typedThing('isURI', 'boolean'), p[3]) if funcName == 'IT_STR': return (typedThing('String', 'literal', ['literal', 'symbol']), p[3]) if funcName == 'IT_LANG': return (typedThing('lang', 'literal', ['literal']), p[3]) if funcName == 'IT_DATATYPE': return (typedThing('datatype', 'symbol', ['literal']), p[3]) if funcName == 'IT_isBLANK': return (typedThing('isBlank', 'boolean'), p[3]) if funcName == 'IT_isLITERAL': return (typedThing('isLiteral', 'boolean'), p[3]) raise RuntimeError(`p`) def on_RegexExpression(self, p): return ('Regex', p[3], p[5], p[6]) def on__O_QCOMMA_E____QExpression_E__C(self, p): return p[2] def on__Q_O_QCOMMA_E____QExpression_E__C_E_Opt(self, p): if len(p) == 1: return ('Literal', self.store.newLiteral('')) return p[1] def on_FunctionCall(self, p): return ['function', ("funcName", p[1][1].uriref(),)] + p[2] def on_ArgList(self, p): return p[2] def on__Q_O_QCOMMA_E____QExpression_E__C_E_Star(self, p): if len(p) == 1: return [] return [p[1]] + p[2] def on__O_QExpression_E____QCOMMA_E____QExpression_E_Star_C(self, p): return [p[1]] + p[2] def on__Q_O_QExpression_E____QCOMMA_E____QExpression_E_Star_C_E_Opt(self, p): if len(p) == 1: return [] return p[1] def on_RDFTermOrFunc(self, p): if p[1][0] == 'Literal': lit = p[1][1] if not lit.datatype: return (typedThing('String', 'string'), lit) if lit.datatype in self.numTypes: return (typedThing('Number', 'number'), lit) if lit.datatype == self.xsd['boolean']: return (typedThing('Boolean', 'boolean'), lit) return p[1] def on_IRIrefOrFunc(self, p): if p[2] == None: return p[1] return ['function', ("funcName", p[1][1].uriref(),)] + p[2] def on__QArgList_E_Opt(self, p): if len(p) == 1: return None return p[1] def on__O_QDTYPE_E____QIRIref_E__C(self, p): return (p[1][0], p[2][1]) def on__O_QLANGTAG_E__Or__QDTYPE_E____QIRIref_E__C(self, p): if abbr(p[1][0]) == 'LANGTAG': return (None, p[1][1][1:]) if abbr(p[1][0]) == 'GT_DTYPE': return (p[1][1], None) raise RuntimeError(`p`) def on_BooleanLiteral(self, p): return ('Literal', (p[1][1] == u'true' and self.true or self.false)) class RulesMaker(object): def __init__(self, ns): self.ns = ns def implications(self, query, formula, totalResult): retFormula = formula.newFormula() for where in formula.each(subj=query, pred=self.ns['where']): F = formula.newFormula() F.existentials().update(totalResult.existentials()) bound_vars = self.find_vars(formula.universals(), where) # print where, bound_vars unbound_vars = formula.universals() - bound_vars self.matching_subformula(F, unbound_vars, totalResult) retFormula.add(where, self.ns['implies'], F.close(), why=reason2()) return retFormula def find_vars(self, vars, f): # print 'find_vars on:', f, vars retVal = Set() for var in vars: if f.contains(subj=var) or f.contains(pred=var) or f.contains(obj=var): retVal.add(var) for statement in f.statementsMatching(pred=f.store.includes): retVal.update(self.find_vars(vars, statement.object())) # print 'find_vars found:', retVal, ' on ', f, vars return retVal def matching_subformula(self, retF, illegals, F): def clear(node): return node not in illegals and not (isinstance(node, CompoundTerm) and False in [clear(a) for a in node]) for triple in F: if (clear(triple.subject()) and clear(triple.predicate()) and clear(triple.object())): retF.add(*triple.spo(), **{'why':reason2()}) # else: # print triple, illegals def unEscape(string): if string[:1] == '"': delin = '"' if string[:3] == '"""': real_str = string[3:-3] triple = True else: real_str = string[1:-1] triple = False else: delin = "'" if string[:3] == "'''": real_str = string[3:-3] triple = True else: real_str = string[1:-1] triple = False ret = u'' n = 0 while n < len(real_str): ch = real_str[n] if ch == '\r': pass elif ch == '\\': a = real_str[n+1:n+2] if a == '': raise RuntimeError k = 'abfrtvn\\"\''.find(a) if k >= 0: ret += '\a\b\f\r\t\v\n\\"\''[k] n += 1 elif a == 'u': m = real_str[n+2:n+6] assert len(m) == 4 ret += unichr(int(m, 16)) n += 5 elif a == 'U': m = real_str[n+2:n+10] assert len(m) == 8 ret += unichr(int(m, 16)) n += 9 else: raise ValueError('Bad Escape') else: ret += ch n += 1 return ret def intConvert(self, keepGoing, val): return self.typeConvert(keepGoing, 'http://www.w3.org/2001/XMLSchema#integer', val) knownFunctions['http://www.w3.org/2001/XMLSchema#integer'] = intConvert def sparqlLookup(uri, server, property): pass