diff --git a/rdflib/plugins/sparql/parser.py b/rdflib/plugins/sparql/parser.py index 789d0761..beb7aa6f 100644 --- a/rdflib/plugins/sparql/parser.py +++ b/rdflib/plugins/sparql/parser.py @@ -24,14 +24,13 @@ from pyparsing import ( Regex, Suppress, ZeroOrMore, - delimitedList, - restOfLine, ) import rdflib from rdflib.compat import decodeUnicodeEscape from . import operators as op +from .pyparsing_compat import DelimitedList, combine_join_kwargs, rest_of_line from .parserutils import Comp, CompValue, Param, ParamList # from pyparsing import Keyword as CaseSensitiveKeyword @@ -89,7 +88,7 @@ def expandTriples(terms: ParseResults) -> List[Any]: last_subject, last_predicate = t[0], None res.append(t[0]) elif isinstance(t, ParseResults): - res += t.asList() + res += t.as_list() elif t != ".": res.append(t) if (len(res) % 3) == 1: @@ -126,8 +125,8 @@ def expandBNodeTriples(terms: ParseResults) -> List[Any]: if DEBUG: print("Bnode terms", terms) print("1", terms[0]) - print("2", [rdflib.BNode()] + terms.asList()[0]) - return [expandTriples([rdflib.BNode()] + terms.asList()[0])] + print("2", [rdflib.BNode()] + terms.as_list()[0]) + return [expandTriples([rdflib.BNode()] + terms.as_list()[0])] except Exception as e: if DEBUG: print(">>>>>>>>", e) @@ -170,7 +169,7 @@ IRIREF = Combine( + Regex(r'[^<>"{}|^`\\%s]*' % "".join("\\x%02X" % i for i in range(33))) + Suppress(">") ) -IRIREF.setParseAction(lambda x: rdflib.URIRef(x[0])) +IRIREF.set_parse_action(lambda x: rdflib.URIRef(x[0])) # [164] P_CHARS_BASE ::= [A-Z] | [a-z] | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D] | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF] @@ -209,13 +208,13 @@ PN_PREFIX = Regex( ) # [140] PNAME_NS ::= PN_PREFIX? ':' -PNAME_NS = Optional(Param("prefix", PN_PREFIX)) + Suppress(":").leaveWhitespace() +PNAME_NS = Optional(Param("prefix", PN_PREFIX)) + Suppress(":").leave_whitespace() # [173] PN_LOCAL_ESC ::= '\' ( '_' | '~' | '.' | '-' | '!' | '$' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | ';' | '=' | '/' | '?' | '#' | '@' | '%' ) PN_LOCAL_ESC_re = "\\\\[_~\\.\\-!$&\"'()*+,;=/?#@%]" # PN_LOCAL_ESC = Regex(PN_LOCAL_ESC_re) # regex'd -# PN_LOCAL_ESC.setParseAction(lambda x: x[0][1:]) +# PN_LOCAL_ESC.set_parse_action(lambda x: x[0][1:]) # [172] HEX ::= [0-9] | [A-F] | [a-f] # HEX = Regex('[0-9A-Fa-f]') # not needed @@ -223,7 +222,7 @@ PN_LOCAL_ESC_re = "\\\\[_~\\.\\-!$&\"'()*+,;=/?#@%]" # [171] PERCENT ::= '%' HEX HEX PERCENT_re = "%[0-9a-fA-F]{2}" # PERCENT = Regex(PERCENT_re) # regex'd -# PERCENT.setParseAction(lambda x: chr(int(x[0][1:], 16))) +# PERCENT.set_parse_action(lambda x: chr(int(x[0][1:], 16))) # [170] PLX ::= PERCENT | PN_LOCAL_ESC PLX_re = "(%s|%s)" % (PN_LOCAL_ESC_re, PERCENT_re) @@ -242,14 +241,14 @@ PN_LOCAL = Regex( # [141] PNAME_LN ::= PNAME_NS PN_LOCAL -PNAME_LN = PNAME_NS + Param("localname", PN_LOCAL.leaveWhitespace()) +PNAME_LN = PNAME_NS + Param("localname", PN_LOCAL.leave_whitespace()) # [142] BLANK_NODE_LABEL ::= '_:' ( PN_CHARS_U | [0-9] ) ((PN_CHARS|'.')* PN_CHARS)? BLANK_NODE_LABEL = Regex( "_:[0-9%s](?:[\\.%s]*[%s])?" % (PN_CHARS_U_re, PN_CHARS_re, PN_CHARS_re), flags=re.U, ) -BLANK_NODE_LABEL.setParseAction(lambda x: rdflib.BNode(x[0][2:])) +BLANK_NODE_LABEL.set_parse_action(lambda x: rdflib.BNode(x[0][2:])) # [166] VARNAME ::= ( PN_CHARS_U | [0-9] ) ( PN_CHARS_U | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040] )* @@ -269,46 +268,46 @@ LANGTAG = Combine(Suppress("@") + Regex("[a-zA-Z]+(?:-[a-zA-Z0-9]+)*")) # [146] INTEGER ::= [0-9]+ INTEGER = Regex(r"[0-9]+") -# INTEGER.setResultsName('integer') -INTEGER.setParseAction(lambda x: rdflib.Literal(x[0], datatype=rdflib.XSD.integer)) +# INTEGER.set_results_name('integer') +INTEGER.set_parse_action(lambda x: rdflib.Literal(x[0], datatype=rdflib.XSD.integer)) # [155] EXPONENT ::= [eE] [+-]? [0-9]+ EXPONENT_re = "[eE][+-]?[0-9]+" # [147] DECIMAL ::= [0-9]* '.' [0-9]+ DECIMAL = Regex(r"[0-9]*\.[0-9]+") # (?![eE]) -# DECIMAL.setResultsName('decimal') -DECIMAL.setParseAction(lambda x: rdflib.Literal(x[0], datatype=rdflib.XSD.decimal)) +# DECIMAL.set_results_name('decimal') +DECIMAL.set_parse_action(lambda x: rdflib.Literal(x[0], datatype=rdflib.XSD.decimal)) # [148] DOUBLE ::= [0-9]+ '.' [0-9]* EXPONENT | '.' ([0-9])+ EXPONENT | ([0-9])+ EXPONENT DOUBLE = Regex(r"[0-9]+\.[0-9]*%(e)s|\.([0-9])+%(e)s|[0-9]+%(e)s" % {"e": EXPONENT_re}) -# DOUBLE.setResultsName('double') -DOUBLE.setParseAction(lambda x: rdflib.Literal(x[0], datatype=rdflib.XSD.double)) +# DOUBLE.set_results_name('double') +DOUBLE.set_parse_action(lambda x: rdflib.Literal(x[0], datatype=rdflib.XSD.double)) # [149] INTEGER_POSITIVE ::= '+' INTEGER -INTEGER_POSITIVE = Suppress("+") + INTEGER.copy().leaveWhitespace() -INTEGER_POSITIVE.setParseAction( +INTEGER_POSITIVE = Suppress("+") + INTEGER.copy().leave_whitespace() +INTEGER_POSITIVE.set_parse_action( lambda x: rdflib.Literal("+" + x[0], datatype=rdflib.XSD.integer) ) # [150] DECIMAL_POSITIVE ::= '+' DECIMAL -DECIMAL_POSITIVE = Suppress("+") + DECIMAL.copy().leaveWhitespace() +DECIMAL_POSITIVE = Suppress("+") + DECIMAL.copy().leave_whitespace() # [151] DOUBLE_POSITIVE ::= '+' DOUBLE -DOUBLE_POSITIVE = Suppress("+") + DOUBLE.copy().leaveWhitespace() +DOUBLE_POSITIVE = Suppress("+") + DOUBLE.copy().leave_whitespace() # [152] INTEGER_NEGATIVE ::= '-' INTEGER -INTEGER_NEGATIVE = Suppress("-") + INTEGER.copy().leaveWhitespace() -INTEGER_NEGATIVE.setParseAction(lambda x: neg(x[0])) +INTEGER_NEGATIVE = Suppress("-") + INTEGER.copy().leave_whitespace() +INTEGER_NEGATIVE.set_parse_action(lambda x: neg(x[0])) # [153] DECIMAL_NEGATIVE ::= '-' DECIMAL -DECIMAL_NEGATIVE = Suppress("-") + DECIMAL.copy().leaveWhitespace() -DECIMAL_NEGATIVE.setParseAction(lambda x: neg(x[0])) +DECIMAL_NEGATIVE = Suppress("-") + DECIMAL.copy().leave_whitespace() +DECIMAL_NEGATIVE.set_parse_action(lambda x: neg(x[0])) # [154] DOUBLE_NEGATIVE ::= '-' DOUBLE -DOUBLE_NEGATIVE = Suppress("-") + DOUBLE.copy().leaveWhitespace() -DOUBLE_NEGATIVE.setParseAction(lambda x: neg(x[0])) +DOUBLE_NEGATIVE = Suppress("-") + DOUBLE.copy().leave_whitespace() +DOUBLE_NEGATIVE.set_parse_action(lambda x: neg(x[0])) # [160] ECHAR ::= '\' [tbnrf\"'] # ECHAR = Regex('\\\\[tbnrf"\']') @@ -318,7 +317,7 @@ DOUBLE_NEGATIVE.setParseAction(lambda x: neg(x[0])) # STRING_LITERAL_LONG1 = Literal("'''") + ( Optional( Literal("'") | "''" # ) + ZeroOrMore( ~ Literal("'\\") | ECHAR ) ) + "'''" STRING_LITERAL_LONG1 = Regex("'''((?:'|'')?(?:[^'\\\\]|\\\\['ntbrf\\\\]))*'''") -STRING_LITERAL_LONG1.setParseAction( +STRING_LITERAL_LONG1.set_parse_action( lambda x: rdflib.Literal(decodeUnicodeEscape(x[0][3:-3])) ) @@ -326,7 +325,7 @@ STRING_LITERAL_LONG1.setParseAction( # STRING_LITERAL_LONG2 = Literal('"""') + ( Optional( Literal('"') | '""' # ) + ZeroOrMore( ~ Literal('"\\') | ECHAR ) ) + '"""' STRING_LITERAL_LONG2 = Regex('"""(?:(?:"|"")?(?:[^"\\\\]|\\\\["ntbrf\\\\]))*"""') -STRING_LITERAL_LONG2.setParseAction( +STRING_LITERAL_LONG2.set_parse_action( lambda x: rdflib.Literal(decodeUnicodeEscape(x[0][3:-3])) ) @@ -335,7 +334,7 @@ STRING_LITERAL_LONG2.setParseAction( # Regex(u'[^\u0027\u005C\u000A\u000D]',flags=re.U) | ECHAR ) + "'" STRING_LITERAL1 = Regex("'(?:[^'\\n\\r\\\\]|\\\\['ntbrf\\\\])*'(?!')", flags=re.U) -STRING_LITERAL1.setParseAction( +STRING_LITERAL1.set_parse_action( lambda x: rdflib.Literal(decodeUnicodeEscape(x[0][1:-1])) ) @@ -344,24 +343,24 @@ STRING_LITERAL1.setParseAction( # Regex(u'[^\u0022\u005C\u000A\u000D]',flags=re.U) | ECHAR ) + '"' STRING_LITERAL2 = Regex('"(?:[^"\\n\\r\\\\]|\\\\["ntbrf\\\\])*"(?!")', flags=re.U) -STRING_LITERAL2.setParseAction( +STRING_LITERAL2.set_parse_action( lambda x: rdflib.Literal(decodeUnicodeEscape(x[0][1:-1])) ) # [161] NIL ::= '(' WS* ')' NIL = Literal("(") + ")" -NIL.setParseAction(lambda x: rdflib.RDF.nil) +NIL.set_parse_action(lambda x: rdflib.RDF.nil) # [162] WS ::= #x20 | #x9 | #xD | #xA # Not needed? # WS = #x20 | #x9 | #xD | #xA # [163] ANON ::= '[' WS* ']' ANON = Literal("[") + "]" -ANON.setParseAction(lambda x: rdflib.BNode()) +ANON.set_parse_action(lambda x: rdflib.BNode()) # A = CaseSensitiveKeyword('a') A = Literal("a") -A.setParseAction(lambda x: rdflib.RDF.type) +A.set_parse_action(lambda x: rdflib.RDF.type) # ------ NON-TERMINALS -------------- @@ -377,7 +376,7 @@ Prologue = Group(ZeroOrMore(BaseDecl | PrefixDecl)) # [108] Var ::= VAR1 | VAR2 Var = VAR1 | VAR2 -Var.setParseAction(lambda x: rdflib.term.Variable(x[0])) +Var.set_parse_action(lambda x: rdflib.term.Variable(x[0])) # [137] PrefixedName ::= PNAME_LN | PNAME_NS PrefixedName = Comp("pname", PNAME_LN | PNAME_NS) @@ -394,8 +393,8 @@ RDFLiteral = Comp( "literal", Param("string", String) + Optional( - Param("lang", LANGTAG.leaveWhitespace()) - | Literal("^^").leaveWhitespace() + Param("datatype", iri).leaveWhitespace() + Param("lang", LANGTAG.leave_whitespace()) + | Literal("^^").leave_whitespace() + Param("datatype", iri).leave_whitespace() ), ) @@ -414,9 +413,9 @@ NumericLiteral = ( ) # [134] BooleanLiteral ::= 'true' | 'false' -BooleanLiteral = Keyword("true").setParseAction(lambda: rdflib.Literal(True)) | Keyword( - "false" -).setParseAction(lambda: rdflib.Literal(False)) +BooleanLiteral = Keyword("true").set_parse_action( + lambda: rdflib.Literal(True) +) | Keyword("false").set_parse_action(lambda: rdflib.Literal(False)) # [138] BlankNode ::= BLANK_NODE_LABEL | ANON BlankNode = BLANK_NODE_LABEL | ANON @@ -502,7 +501,7 @@ PathPrimary = ( # [91] PathElt ::= PathPrimary Optional(PathMod) PathElt = Comp( "PathElt", - Param("part", PathPrimary) + Optional(Param("mod", PathMod.leaveWhitespace())), + Param("part", PathPrimary) + Optional(Param("mod", PathMod.leave_whitespace())), ) # [92] PathEltOrInverse ::= PathElt | '^' PathElt @@ -542,11 +541,11 @@ GroupGraphPattern = Forward() # [102] Collection ::= '(' OneOrMore(GraphNode) ')' Collection = Suppress("(") + OneOrMore(GraphNode) + Suppress(")") -Collection.setParseAction(expandCollection) +Collection.set_parse_action(expandCollection) # [103] CollectionPath ::= '(' OneOrMore(GraphNodePath) ')' CollectionPath = Suppress("(") + OneOrMore(GraphNodePath) + Suppress(")") -CollectionPath.setParseAction(expandCollection) +CollectionPath.set_parse_action(expandCollection) # [80] Object ::= GraphNode Object = GraphNode @@ -573,13 +572,13 @@ PropertyList = Optional(PropertyListNotEmpty) # [99] BlankNodePropertyList ::= '[' PropertyListNotEmpty ']' BlankNodePropertyList = Group(Suppress("[") + PropertyListNotEmpty + Suppress("]")) -BlankNodePropertyList.setParseAction(expandBNodeTriples) +BlankNodePropertyList.set_parse_action(expandBNodeTriples) # [101] BlankNodePropertyListPath ::= '[' PropertyListPathNotEmpty ']' BlankNodePropertyListPath = Group( Suppress("[") + PropertyListPathNotEmpty + Suppress("]") ) -BlankNodePropertyListPath.setParseAction(expandBNodeTriples) +BlankNodePropertyListPath.set_parse_action(expandBNodeTriples) # [98] TriplesNode ::= Collection | BlankNodePropertyList TriplesNode <<= Collection | BlankNodePropertyList @@ -589,7 +588,7 @@ TriplesNodePath <<= CollectionPath | BlankNodePropertyListPath # [75] TriplesSameSubject ::= VarOrTerm PropertyListNotEmpty | TriplesNode PropertyList TriplesSameSubject = VarOrTerm + PropertyListNotEmpty | TriplesNode + PropertyList -TriplesSameSubject.setParseAction(expandTriples) +TriplesSameSubject.set_parse_action(expandTriples) # [52] TriplesTemplate ::= TriplesSameSubject ( '.' TriplesTemplate? )? # NOTE: pyparsing.py handling of recursive rules is limited by python's recursion @@ -629,7 +628,7 @@ QuadData = "{" + Param("quads", Quads) + "}" TriplesSameSubjectPath = ( VarOrTerm + PropertyListPathNotEmpty | TriplesNodePath + PropertyListPath ) -TriplesSameSubjectPath.setParseAction(expandTriples) +TriplesSameSubjectPath.set_parse_action(expandTriples) # [55] TriplesBlock ::= TriplesSameSubjectPath ( '.' Optional(TriplesBlock) )? TriplesBlock = Forward() @@ -654,7 +653,7 @@ GroupOrUnionGraphPattern = Comp( Expression = Forward() # [72] ExpressionList ::= NIL | '(' Expression ( ',' Expression )* ')' -ExpressionList = NIL | Group(Suppress("(") + delimitedList(Expression) + Suppress(")")) +ExpressionList = NIL | Group(Suppress("(") + DelimitedList(Expression) + Suppress(")")) # [122] RegexExpression ::= 'REGEX' '(' Expression ',' Expression ( ',' Expression )? ')' RegexExpression = Comp( @@ -1015,7 +1014,7 @@ ArgList = ( NIL | "(" + Param("distinct", _Distinct) - + delimitedList(ParamList("expr", Expression)) + + DelimitedList(ParamList("expr", Expression)) + ")" ) @@ -1101,7 +1100,11 @@ RelationalExpression = Comp( | Param("op", Keyword("IN")) + Param("other", ExpressionList) | Param( "op", - Combine(Keyword("NOT") + Keyword("IN"), adjacent=False, joinString=" "), + Combine( + Keyword("NOT") + Keyword("IN"), + adjacent=False, + **combine_join_kwargs(" "), + ), ) + Param("other", ExpressionList) ), @@ -1519,8 +1522,8 @@ UpdateUnit = Comp("Update", Update) # [1] QueryUnit ::= Query QueryUnit = Query -QueryUnit.ignore("#" + restOfLine) -UpdateUnit.ignore("#" + restOfLine) +QueryUnit.ignore("#" + rest_of_line) +UpdateUnit.ignore("#" + rest_of_line) expandUnicodeEscapes_re: re.Pattern = re.compile( @@ -1550,7 +1553,7 @@ def parseQuery(q: Union[str, bytes, TextIO, BinaryIO]) -> ParseResults: q = q.decode("utf-8") q = expandUnicodeEscapes(q) - return Query.parseString(q, parseAll=True) + return Query.parse_string(q, parse_all=True) def parseUpdate(q: Union[str, bytes, TextIO, BinaryIO]) -> CompValue: @@ -1561,4 +1564,4 @@ def parseUpdate(q: Union[str, bytes, TextIO, BinaryIO]) -> CompValue: q = q.decode("utf-8") q = expandUnicodeEscapes(q) - return UpdateUnit.parseString(q, parseAll=True)[0] + return UpdateUnit.parse_string(q, parse_all=True)[0] diff --git a/rdflib/plugins/sparql/parserutils.py b/rdflib/plugins/sparql/parserutils.py index 43af286c..9b6be93a 100644 --- a/rdflib/plugins/sparql/parserutils.py +++ b/rdflib/plugins/sparql/parserutils.py @@ -39,10 +39,12 @@ from typing import ( Union, ) -from pyparsing import ParserElement, ParseResults, TokenConverter, originalTextFor +from pyparsing import ParserElement, ParseResults, TokenConverter from rdflib.term import BNode, Identifier, Variable +from .pyparsing_compat import original_text_for + if TYPE_CHECKING: from rdflib.plugins.sparql.sparql import FrozenBindings @@ -126,8 +128,8 @@ class Param(TokenConverter): def __init__(self, name: str, expr, isList: bool = False): self.isList = isList TokenConverter.__init__(self, expr) - self.setName(name) - self.addParseAction(self.postParse2) + self.set_name(name) + self.add_parse_action(self.postParse2) def postParse2(self, tokenList: Union[List[Any], ParseResults]) -> ParamValue: return ParamValue(self.name, tokenList, self.isList) @@ -236,7 +238,7 @@ class Comp(TokenConverter): def __init__(self, name: str, expr: ParserElement): self.expr = expr TokenConverter.__init__(self, expr) - self.setName(name) + self.set_name(name) self.evalfn: Optional[Callable[[Any, Any], Any]] = None def postParse( @@ -252,8 +254,8 @@ class Comp(TokenConverter): # Then this must be a service graph pattern and have # already matched. # lets assume there is one, for now, then test for two later. - sgp = originalTextFor(self.expr) - service_string = sgp.searchString(instring)[0][0] + sgp = original_text_for(self.expr) + service_string = sgp.search_string(instring)[0][0] res["service_string"] = service_string for t in tokenList: @@ -276,7 +278,7 @@ class Comp(TokenConverter): def prettify_parsetree(t: ParseResults, indent: str = "", depth: int = 0) -> str: out: List[str] = [] - for e in t.asList(): + for e in t.as_list(): out.append(_prettify_sub_parsetree(e, indent, depth + 1)) for k, v in sorted(t.items()): out.append("%s%s- %s:\n" % (indent, " " * depth, k)) diff --git a/rdflib/plugins/sparql/pyparsing_compat.py b/rdflib/plugins/sparql/pyparsing_compat.py new file mode 100644 index 00000000..91a0c737 --- /dev/null +++ b/rdflib/plugins/sparql/pyparsing_compat.py @@ -0,0 +1,100 @@ +""" +Compatibility helpers for supporting pyparsing v2 and v3 APIs. +""" + +from __future__ import annotations + +from typing import Callable, Dict, Type, cast + +import pyparsing + +ParseResults = pyparsing.ParseResults +ParserElement = pyparsing.ParserElement + + +_RAW_VERSION = getattr(pyparsing, "__version__", "0") +try: + PYPARSING_MAJOR_VERSION = int(_RAW_VERSION.split(".", 1)[0]) +except (TypeError, ValueError): + PYPARSING_MAJOR_VERSION = 0 + +PYPARSING_V3 = PYPARSING_MAJOR_VERSION >= 3 + +_ParserFactory = Callable[..., ParserElement] +_ParserTransform = Callable[..., ParserElement] + +DelimitedList: _ParserFactory +original_text_for: _ParserTransform +rest_of_line: ParserElement + +if PYPARSING_V3: + DelimitedList = pyparsing.DelimitedList + original_text_for = pyparsing.original_text_for + rest_of_line = pyparsing.rest_of_line +else: + DelimitedList = pyparsing.delimitedList + original_text_for = pyparsing.originalTextFor + rest_of_line = pyparsing.restOfLine + + +def _alias_instance_method(klass: Type[object], new_name: str, old_name: str) -> None: + if hasattr(klass, new_name) or not hasattr(klass, old_name): + return + + def _method(self: object, *args: object, **kwargs: object) -> object: + # Resolve old_name on self so subclass overrides are preserved. + method = cast(Callable[..., object], getattr(self, old_name)) + return method(*args, **kwargs) + + setattr(klass, new_name, _method) + + +def _alias_static_method(klass: Type[object], new_name: str, old_name: str) -> None: + if hasattr(klass, new_name) or not hasattr(klass, old_name): + return + + old_method = cast(Callable[..., object], getattr(klass, old_name)) + + def _method(*args: object, **kwargs: object) -> object: + return old_method(*args, **kwargs) + + setattr(klass, new_name, staticmethod(_method)) + + +_alias_instance_method(ParserElement, "set_parse_action", "setParseAction") +_alias_instance_method(ParserElement, "add_parse_action", "addParseAction") +_alias_instance_method(ParserElement, "leave_whitespace", "leaveWhitespace") +_alias_instance_method(ParserElement, "set_name", "setName") +_alias_instance_method(ParserElement, "set_results_name", "setResultsName") +_alias_instance_method(ParserElement, "parse_with_tabs", "parseWithTabs") +_alias_instance_method(ParserElement, "search_string", "searchString") +_alias_static_method( + ParserElement, + "set_default_whitespace_chars", + "setDefaultWhitespaceChars", +) + +if not hasattr(ParserElement, "parse_string"): + + def _parse_string( + self: ParserElement, + instring: str, + parse_all: bool = False, + *, + parseAll: bool = False, + ) -> ParseResults: + if parseAll: + parse_all = parseAll + parser = cast(Callable[..., ParseResults], getattr(self, "parseString")) + return parser(instring, parseAll=parse_all) + + setattr(ParserElement, "parse_string", _parse_string) + + +_alias_instance_method(ParseResults, "as_list", "asList") + + +def combine_join_kwargs(value: str) -> Dict[str, str]: + if PYPARSING_V3: + return {"join_string": value} + return {"joinString": value} diff --git a/rdflib/plugins/sparql/results/tsvresults.py b/rdflib/plugins/sparql/results/tsvresults.py index 14741718..54d8ee16 100644 --- a/rdflib/plugins/sparql/results/tsvresults.py +++ b/rdflib/plugins/sparql/results/tsvresults.py @@ -32,10 +32,10 @@ from rdflib.plugins.sparql.parser import ( ) from rdflib.plugins.sparql.parserutils import Comp, CompValue, Param from rdflib.query import Result, ResultParser -from rdflib.term import BNode, URIRef +from rdflib.term import BNode, Identifier, URIRef from rdflib.term import Literal as RDFLiteral -ParserElement.setDefaultWhitespaceChars(" \n") +ParserElement.set_default_whitespace_chars(" \n") String = STRING_LITERAL1 | STRING_LITERAL2 @@ -44,23 +44,24 @@ RDFLITERAL = Comp( "literal", Param("string", String) + Optional( - Param("lang", LANGTAG.leaveWhitespace()) - | Literal("^^").leaveWhitespace() + Param("datatype", IRIREF).leaveWhitespace() + Param("lang", LANGTAG.leave_whitespace()) + | Literal("^^").leave_whitespace() + + Param("datatype", IRIREF).leave_whitespace() ), ) NONE_VALUE = object() EMPTY = FollowedBy(LineEnd()) | FollowedBy("\t") -EMPTY.setParseAction(lambda x: NONE_VALUE) +EMPTY.set_parse_action(lambda x: NONE_VALUE) TERM = RDFLITERAL | IRIREF | BLANK_NODE_LABEL | NumericLiteral | BooleanLiteral ROW = (EMPTY | TERM) + ZeroOrMore(Suppress("\t") + (EMPTY | TERM)) -ROW.parseWithTabs() +ROW.parse_with_tabs() HEADER = Var + ZeroOrMore(Suppress("\t") + Var) -HEADER.parseWithTabs() +HEADER.parse_with_tabs() class TSVResultParser(ResultParser): @@ -77,7 +78,7 @@ class TSVResultParser(ResultParser): header = source.readline() - r.vars = list(HEADER.parseString(header.strip(), parseAll=True)) + r.vars = list(HEADER.parse_string(header.strip(), parse_all=True)) r.bindings = [] while True: line = source.readline() @@ -87,15 +88,21 @@ class TSVResultParser(ResultParser): if line == "": continue - row = ROW.parseString(line, parseAll=True) - # type error: Generator has incompatible item type "object"; expected "Identifier" - r.bindings.append(dict(zip(r.vars, (self.convertTerm(x) for x in row)))) # type: ignore[misc] - + row = ROW.parse_string(line, parse_all=True) + this_row_dict = {} + for var, val_read in zip(r.vars, row): + val = self.convertTerm(val_read) + if val is None: + # Skip unbound vars + continue + this_row_dict[var] = val + # Preserve solution row cardinality, including fully-unbound rows. + r.bindings.append(this_row_dict) return r def convertTerm( self, t: Union[object, RDFLiteral, BNode, CompValue, URIRef] - ) -> typing.Optional[Union[object, BNode, URIRef, RDFLiteral]]: + ) -> typing.Optional[Identifier]: if t is NONE_VALUE: return None if isinstance(t, CompValue): @@ -103,5 +110,7 @@ class TSVResultParser(ResultParser): return RDFLiteral(t.string, lang=t.lang, datatype=t.datatype) else: raise Exception("I dont know how to handle this: %s" % (t,)) - else: + elif isinstance(t, (RDFLiteral, BNode, URIRef)): return t + else: + raise ValueError(f"Unexpected type {type(t)} found in TSV result")