def completeElement(self, ctx): try: parsedFields = utils.pyparseString(self._fieldsGrammar, self.content_) except pyparsing.ParseBaseException, ex: raise base.ui.logOldExc(base.LiteralParseError("binaryRecordDef", re.sub("\s+", " ", self.content_), pos=str(ex.loc), hint="The parser said: '%s'"%str(ex)))
def parseDateExprToMJD(str, baseSymbol=getComplexGrammar(_DATE_LITERAL_DT, _makeMJDPmNode, floatLiteral, MJDNode)): """returns a parse tree for vizier-like expression of ISO dates with parsed values in MJD. """ return utils.pyparseString(baseSymbol, str)[0]
def parseDateExpr(str, baseSymbol=getComplexGrammar(_DATE_LITERAL_DT, _makeDatePmNode, floatLiteral, DateNode)): """returns a parse tree for vizier-like expressions over ISO dates. Note that the semantic validity of the date (like, month<13) is not checked by the grammar. """ return utils.pyparseString(baseSymbol, str)[0]
def getREForShPat(shPat): r"""returns a POSIX RE for a POSIX shell pattern. >>> getREForShPat(r"ZU?\*[!A-Z]*") 'ZU.\\*[^A\\-Z].*' >>> getREForShPat("no[*") 'no\\[.*' """ return "".join( utils.pyparseString(_getShPatGrammar(), shPat, parseAll=True))
def parseUploadString(uploadString): """iterates over pairs of tableName, uploadSource from a TAP upload string. """ try: res = utils.pyparseString(getUploadGrammar(), uploadString).asList() return res except ParseException, ex: raise base.ValidationError( "Syntax error in UPLOAD parameter (near %s)" % (ex.loc), "UPLOAD", hint= "Note that we only allow regular SQL identifiers as table names," " i.e., basically only alphanumerics are allowed.")
def _parseColDefs(self, ctx): # the handler for colDefs -- parse shortcut colDefs try: for key, range in utils.pyparseString(self._getColDefGrammar(), self.colDefs): self.colRanges[key] = self._cols.itemAttD.parse(range) except pyparsing.ParseException, ex: raise base.LiteralParseError( "colDefs", self.colDefs, hint="colDefs is a whitespace-separated list of key:range pairs." " Your literal doesn't look like this, and here's what the" " parser had to complain: %s" % ex)
def parse(s): if s is None or not s.strip(): # special service: Null values return None if isinstance(s, pgsphere.PgSAdapter): return s try: res = utils.pyparseString(region, s, parseAll=True)[0] if not res.cooSys or res.cooSys.lower()=='unknownframe': # Sigh. res.cooSys = "UNKNOWN" return res except (ParseException, ParseSyntaxException), msg: raise common.STCSParseError("Invalid STCS (%s)"%str(msg))
def processXML(document, manipulator): """processes an XML-document with manipulator. document is a string containing the XML, and the function returns serialized an XML. You're doing yourself a favour if document is a unicode string. manipulator is an instance of a derivation of Manipulator below. There's a secret handshake between Manipulator and the grammar, so you really need to inherit, just putting in the two methods won't do. """ syms = getXMLGrammar(manipulator) # from gavo.adql import grammar; grammar.enableDebug(syms) res = utils.pyparseString(syms["document"], document) return flatten(res)
def getCST(literal, grammarFactory=None): """returns a CST for an STC-S expression. grammarFactory is a function returning the grammar, in this case either getGrammar (which gets used if the argument is left out) or getColrefGrammar. """ # special case: the empty input yields an empty CST if not literal.strip(): return {} if grammarFactory is None: grammarFactory = getGrammar try: tree = makeTree( utils.pyparseString(grammarFactory()["stcsPhrase"], literal)) except (ParseException, ParseSyntaxException), ex: raise common.STCSParseError("Invalid STCS expression (%s at %s)" % (ex.msg, ex.loc), expr=literal, pos=ex.loc)
def parseStringExpr(str, baseSymbol=getStringGrammar()): return utils.pyparseString(baseSymbol, str)[0]
def parseNumericExpr(str, baseSymbol=getComplexGrammar(floatLiteral, _makePmNode)): """returns a parse tree for vizier-like expressions over floats. """ return utils.pyparseString(baseSymbol, str)[0]
def parseModel(modelDescr): """returns a MetaValidator for a model description. model descriptions are covered in the module docstring. """ return utils.pyparseString(_getModelGrammar(), modelDescr)[0]
def _prepare(self, script): self.statements = utils.pyparseString(getSQLScriptGrammar(), script.getSource())
def parseUnit(unitStr, unitGrammar=getUnitGrammar()): try: return utils.pyparseString(unitGrammar, unitStr, parseAll=True)[0] except pyparsing.ParseException, msg: raise utils.logOldExc( BadUnit("%s at col. %d" % (repr(unitStr), msg.column)))