def get_truncation_language() -> ParserElement: """Build a parser for protein truncations.""" l1 = truncation_tag + nest( amino_acid(AMINO_ACID) + ppc.integer(TRUNCATION_POSITION)) l1.setParseAction(_handle_trunc) l2 = truncation_tag + nest(ppc.integer(TRUNCATION_POSITION)) l2.setParseAction(_handle_trunc_legacy) return l1 | l2
def __init__(self): self.language = psub_tag + nest(amino_acid(PSUB_REFERENCE), ppc.integer(PSUB_POSITION), amino_acid(PSUB_VARIANT)) self.language.setParseAction(self.handle_psub) super(ProteinSubstitutionParser, self).__init__(self.language)
def __init__(self): self.language = gsub_tag + nest(dna_nucleotide(GSUB_REFERENCE), ppc.integer(GSUB_POSITION), dna_nucleotide(GSUB_VARIANT)) self.language.setParseAction(self.handle_gsub) super(GeneSubstitutionParser, self).__init__(self.language)
def __init__(self, identifier_parser=None): """ :param IdentifierParser identifier_parser: An identifier parser for checking the 3P and 5P partners """ self.identifier_parser = identifier_parser if identifier_parser is not None else IdentifierParser( ) pmod_default_ns = oneOf(list( language.pmod_namespace.keys())).setParseAction( self.handle_pmod_default_ns) pmod_legacy_ns = oneOf(list( language.pmod_legacy_labels.keys())).setParseAction( self.handle_pmod_legacy_ns) pmod_identifier = MatchFirst([ Group(self.identifier_parser.identifier_qualified), Group(pmod_default_ns), Group(pmod_legacy_ns) ]) self.language = pmod_tag + nest( pmod_identifier(IDENTIFIER) + Optional(WCW + amino_acid(PMOD_CODE) + Optional(WCW + ppc.integer(PMOD_POSITION)))) super(ProteinModificationParser, self).__init__(self.language)
def get_gene_substitution_language(): language = gsub_tag + nest( dna_nucleotide(GSUB_REFERENCE), ppc.integer(GSUB_POSITION), dna_nucleotide(GSUB_VARIANT), ) language.setParseAction(_handle_gsub) return language
def get_protein_substitution_language(): language = psub_tag + nest( amino_acid(PSUB_REFERENCE), ppc.integer(PSUB_POSITION), amino_acid(PSUB_VARIANT), ) language.setParseAction(_handle_psub) return language
def get_protein_substitution_language() -> ParserElement: """Build a protein substitution parser.""" parser_element = psub_tag + nest( amino_acid(PSUB_REFERENCE), ppc.integer(PSUB_POSITION), amino_acid(PSUB_VARIANT), ) parser_element.setParseAction(_handle_psub) return parser_element
def get_gene_substitution_language() -> ParserElement: """Build a gene substitution parser.""" parser_element = gsub_tag + nest( dna_nucleotide(GSUB_REFERENCE), ppc.integer(GSUB_POSITION), dna_nucleotide(GSUB_VARIANT), ) parser_element.setParseAction(_handle_gsub) return parser_element
def get_protein_modification_language( concept_qualified: ParserElement) -> ParserElement: """Build a protein modification parser.""" pmod_concept = MatchFirst([ concept_qualified, pmod_default_ns, pmod_legacy_ns, ]) return pmod_tag + nest( Group(pmod_concept)(CONCEPT) + Optional( WCW + amino_acid(PMOD_CODE) + Optional(WCW + ppc.integer(PMOD_POSITION)), ), )
def get_protein_modification_language(identifier_qualified): """ :param pyparsing.ParseElement identifier_qualified: :rtype: pyparsing.ParseElement """ pmod_identifier = MatchFirst( [identifier_qualified, pmod_default_ns, pmod_legacy_ns]) return pmod_tag + nest( Group(pmod_identifier)(IDENTIFIER) + Optional(WCW + amino_acid(PMOD_CODE) + Optional(WCW + ppc.integer(PMOD_POSITION))))
def get_protein_modification_language(identifier_qualified: ParserElement) -> ParserElement: """Build a protein modification parser.""" pmod_identifier = MatchFirst([ identifier_qualified, pmod_default_ns, pmod_legacy_ns ]) return pmod_tag + nest( Group(pmod_identifier)(IDENTIFIER) + Optional( WCW + amino_acid(PMOD_CODE) + Optional( WCW + ppc.integer(PMOD_POSITION) ) ) )
def _parse_twr_period(timing_str: str) -> pp.ParseResults: """Parse period constraints from an ISE timing report Expects the default ISE verbose output from a command like: :: trce -v 3 -n 3 -fastpaths top.ncd top.pcf -o top.twr """ # Look for a section of the report like the following and extract the # constraint, path information, and minimum period. # # ================================================================================ # Timing constraint: TS_clk = PERIOD TIMEGRP "clk" 150 MHz HIGH 50%; # For more information, see Period Analysis in the Timing Closure User Guide (UG612). # # 39892 paths analyzed, 3774 endpoints analyzed, 632 failing endpoints # 632 timing errors detected. (632 setup errors, 0 hold errors, 0 component switching limit errors) # Minimum period is 10.877ns. # -------------------------------------------------------------------------------- # # or # # ================================================================================ # Timing constraint: TS_soclinux_crg_pll_sdram_half_b = PERIOD TIMEGRP # "soclinux_crg_pll_sdram_half_b" TS_soclinux_crg_clk50b / 3.33333333 # PHASE 4.16666667 ns HIGH 50%; # For more information, see Period Analysis in the Timing Closure User Guide (UG612). # # 0 paths analyzed, 0 endpoints analyzed, 0 failing endpoints # 0 timing errors detected. (0 component switching limit errors) # Minimum period is 1.730ns. # -------------------------------------------------------------------------------- period = ppc.real("min period") + pp.Suppress("ns") # Build up a case-insensitive match for any of the below units units = ["ps", "ns", "micro", "ms", "%", "MHz", "GHz", "kHz"] pp_units = pp.CaselessLiteral(units[0]) for u in units[1:]: pp_units |= pp.CaselessLiteral(u) hl = pp.Literal("HIGH") | pp.Literal("LOW") num = ppc.number + pp.Optional(pp_units) jitter = pp.Optional("INPUT_JITTER" + num) # Remove leading and trailing whitespace and any line breaks # # SkipTo in the below timespec parser will pickup whitespace including # new lines if they are included in the report. def remove_ws_and_newlines(s): lines = [l.strip() for l in s.splitlines()] return " ".join(lines) timespec = (pp.Suppress("Timing constraint:") + pp.Word(pp.printables)("timespec") + pp.Suppress("= PERIOD TIMEGRP") + pp.Word(pp.printables)("timegroup") + pp.SkipTo(hl)("constraint").setParseAction( pp.tokenMap(remove_ws_and_newlines)) + pp.Suppress(hl + num + jitter + ";")) # Parse the path information from the report like: # # 0 paths analyzed, 0 endpoints analyzed, 0 failing endpoints # 0 timing errors detected. (0 component switching limit errors) # # or # # 266 paths analyzed, 235 endpoints analyzed, 0 failing endpoints # 0 timing errors detected. (0 setup errors, 0 hold errors, 0 component switching limit errors) stats = ( ppc.integer("paths") + pp.Suppress("paths analyzed,") + ppc.integer("endpoints") + pp.Suppress("endpoints analyzed,") + ppc.integer("failing") + pp.Suppress("failing endpoints") + ppc.integer("timing errors") + pp.Suppress("timing errors detected. (") + pp.Optional( ppc.integer("setup errors") + pp.Suppress("setup errors,") + ppc.integer("hold errors") + pp.Suppress("hold errors,")) + ppc.integer("switching limit errors") + pp.Suppress("component switching limit errors)")) # It's not clear why this doesn't show up for one timing constraint in # the LiteX Linux VexRISCV example min_period = pp.Optional(pp.Suppress("Minimum period is") + period) constraint = timespec + pp.Suppress( pp.SkipTo(stats)) + stats + min_period result = constraint.searchString(timing_str) return result
keyword = and_ | or_ | not_ | to_ expression = pp.Forward() valid_word = pp.Regex( r'([a-zA-Z0-9*_+.-]|\\\\|\\([+\-!(){}\[\]^"~*?:]|\|\||&&))+' ).setName("word") valid_word.setParseAction( lambda t: t[0].replace("\\\\", chr(127)).replace("\\", "").replace(chr(127), "\\") ) string = pp.QuotedString('"') required_modifier = pp.Literal("+")("required") prohibit_modifier = pp.Literal("-")("prohibit") integer = ppc.integer() proximity_modifier = pp.Group(TILDE + integer("proximity")) number = ppc.fnumber() fuzzy_modifier = TILDE + pp.Optional(number, default=0.5)("fuzzy") term = pp.Forward() field_name = valid_word().setName("fieldname") incl_range_search = pp.Group(LBRACK - term("lower") + to_ + term("upper") + RBRACK) excl_range_search = pp.Group(LBRACE - term("lower") + to_ + term("upper") + RBRACE) range_search = incl_range_search("incl_range") | excl_range_search("excl_range") boost = CARAT - number("boost") string_expr = pp.Group(string + proximity_modifier) | string word_expr = pp.Group(valid_word + fuzzy_modifier) | valid_word term << ( pp.Optional(field_name("field") + COLON)
TRUE = make_keyword("true", True) FALSE = make_keyword("false", False) NULL = make_keyword("null", None) ed5 = make_keyword("|>|", 'increased_in_magnitude_relative_to') ed6 = make_keyword("|<|", 'decreased_in_magnitude_relative_to') ed7 = make_keyword("|=|", 'has_count') ed1 = make_keyword(">", 'has_part') ed3 = make_keyword("<", 'part_of') ed2 = make_keyword('>>', 'bearer_of') ed4 = make_keyword('<<', 'inheres_in') #graph_word = Word(alphanums +"_", alphanums+"_") #jsonNumber = ppc.number() phsInt = ppc.integer()('num_int') phsReal = ppc.real()('num_real') graph_alphanum = Word(alphanums + "_" + "-") #graph_alphanum = Word(alphanums +"_", alphanums+"_") graph_word = (phsReal | phsInt | graph_alphanum) #----------- Node # Node Properties: N[] propertyWord = Word(alphanums + "_" + ":") # in [] #jsonString = quotedString().setParseAction(removeQuotes) jsonStr = quotedString().setParseAction(removeQuotes) jsonString = (jsonStr | propertyWord) jsonNumber = ppc.number()
def __mk_grammar(self): """ Метод, в котором создаётся описание грамматики, вызывается в конструкторе класса Parser. """ # Описание LiteralNode и IdentNode num = ppc.integer() | ppc.real() str_ = pp.QuotedString('"', escChar='\\', unquoteResults=True, convertWhitespaceEscapes=False) literal = (num | str_).setName('Literal') ident = ppc.identifier.setName('Ident') # Описание ключевых слов VAR_KW, FUNC_KW, RETURN_KW = pp.Keyword('var'), pp.Keyword('function'), pp.Keyword('return') IF_KW, ELSE_KW = pp.Keyword('if'), pp.Keyword('else') FOR_KW, DO_KW, WHILE_KW = pp.Keyword('for'), pp.Keyword('do'), pp.Keyword('while') # Описание различных скобок, запятой и точки с запятой. L_PAR, R_PAR = pp.Literal('(').suppress(), pp.Literal(')').suppress() L_BRACKET, R_BRACKET = pp.Literal('{').suppress(), pp.Literal('}').suppress() SEMICOLON, COMMA = pp.Literal(';').suppress(), pp.Literal(',').suppress() # Описание операторов ASSIGN = pp.Literal('=') ADD, SUB, MUL, DIV, MOD, EXP = pp.Literal('+'), pp.Literal('-'), pp.Literal('*'), pp.Literal('/'), \ pp.Literal('%'), pp.Literal('**') LOG_AND, LOG_OR, LOG_NOT = pp.Literal('&&'), pp.Literal('||'), pp.Literal('!') GT, LT, GE, LE = pp.Literal('>'), pp.Literal('<'), pp.Literal('>='), pp.Literal('<=') NEQ, EQ = pp.Literal('!='), pp.Literal('==') INCR, DECR = pp.Literal('++'), pp.Literal('--') # Объявляем переменные, описывающие операции умножения, сложения и Выражение. Они определяются дальше в коде. mul_op = pp.Forward() add_op = pp.Forward() expr = pp.Forward() # Описание вызова функции call = (ident + L_PAR + pp.Optional(expr + pp.ZeroOrMore(COMMA + expr)) + R_PAR).setName('Call') # Описание унарных операций: инкремент, декремент. incr_op = (ident + INCR).setName('UnaryExpr') decr_op = (ident + DECR).setName('UnaryExpr') group = (literal | call | ident | L_PAR + expr + R_PAR) # Описание бинарных выражений. mul_op << pp.Group(group + pp.ZeroOrMore((EXP | MUL | DIV | MOD) + group)).setName('BinExpr') add_op << pp.Group(mul_op + pp.ZeroOrMore((ADD | SUB) + mul_op)).setName('BinExpr') compare = pp.Group(add_op + pp.ZeroOrMore((GE | LE | GT | LT) + add_op)).setName('BinExpr') compare_eq = pp.Group(compare + pp.ZeroOrMore((EQ | NEQ) + compare)).setName('BinExpr') log_and_op = pp.Group(compare_eq + pp.ZeroOrMore(LOG_AND + compare_eq)).setName('BinExpr') log_or_op = pp.Group(log_and_op + pp.ZeroOrMore(LOG_OR + log_and_op)).setName('BinExpr') expr << log_or_op # Описание присвоения и объявления переменных. assign = (ident + ASSIGN + expr).setName('BinExpr') simple_assign = (ident + ASSIGN.suppress() + expr) var_item = simple_assign | ident simple_var = (VAR_KW.suppress() + var_item).setName('Declarator') mult_var_item = (COMMA + var_item).setName('Declarator') mult_var = (simple_var + pp.ZeroOrMore(mult_var_item)).setName('VarDeclaration') stmt = pp.Forward() simple_stmt = assign | call | incr_op | decr_op # Описание цикла for. for_statement_list = pp.Optional(simple_stmt + pp.ZeroOrMore(COMMA + simple_stmt)).setName('BlockStatement') for_statement = mult_var | for_statement_list for_test = expr | pp.Group(pp.empty) for_block = stmt | pp.Group(SEMICOLON).setName('BlockStatement') # Описание циклов for, while, do while, условного оператора if. if_ = (IF_KW.suppress() + L_PAR + expr + R_PAR + stmt + pp.Optional(ELSE_KW.suppress() + stmt)).setName('If') for_ = (FOR_KW.suppress() + L_PAR + for_statement + SEMICOLON + for_test + SEMICOLON + for_statement + R_PAR + for_block).setName('For') while_ = (WHILE_KW.suppress() + L_PAR + expr + R_PAR + stmt).setName('While') do_while = (DO_KW.suppress() + stmt + WHILE_KW.suppress() + L_PAR + expr + R_PAR).setName('DoWhile') # Описание блока кода в { } и без них, аргументов функции, объявления функции и оператора return. block = pp.ZeroOrMore(stmt + pp.ZeroOrMore(SEMICOLON)).setName('BlockStatement') br_block = L_BRACKET + block + R_BRACKET args = ((expr + pp.ZeroOrMore(COMMA + expr)) | pp.Group(pp.empty)).setName("Args") func_decl = (FUNC_KW.suppress() + ident + L_PAR + args + R_PAR + br_block)\ .setName('FuncDeclaration') return_ = (RETURN_KW.suppress() + expr).setName('Return') stmt << ( if_ | for_ | while_ | do_while | br_block | mult_var + SEMICOLON | simple_stmt + SEMICOLON | func_decl | return_ ) # locals().copy().items() возвращает словарь всех переменных в текущей области видимости # все элементы этого словаря перебираются в цикле for for var_name, value in locals().copy().items(): # проверка на то, что текущий элемент является экземлпяром класса ParserElement if isinstance(value, pp.ParserElement): # вызов метода __set_parse_action self.__set_parse_action(var_name, value) return block.ignore(pp.cStyleComment).ignore(pp.dblSlashComment) + pp.stringEnd
NOT, AND, OR = map(CaselessKeyword, "NOT AND OR".split()) BEFORE, AFTER, JOIN = map(CaselessKeyword, "BEFORE AFTER JOIN".split()) lpar = Suppress('{') rpar = Suppress('}') keyword = MatchFirst([ LINE_CONTAINS, LINE_STARTSWITH, LINE_ENDSWITH, NOT, AND, OR, BEFORE, AFTER, JOIN ]) # declaring all keywords and assigning order for all further use phrase_word = ~keyword + (Word(alphanums + '_')) upto_N_words = Group(lpar + 'upto' + pyparsing_common.integer('numberofwords') + 'words' + rpar) upto_N_chars = Group(lpar + 'upto' + pyparsing_common.integer('numberofchars') + 'characters' + rpar) phrase_term = Group( OneOrMore(phrase_word) + ZeroOrMore(( (upto_N_words) | ZeroOrMore(upto_N_chars)) + OneOrMore(phrase_word)) ) | quotedString # changed phrase_word to OneOrMore(phrase_word) to allow multi-word phrases # phrase-term # want to know if there is a way to just say that the phrase_term can contain both types of elements instead of # having to give the exact grammar for it as p_w+upto+p_W phrase_expr = infixNotation(
LINE_CONTAINS, LINE_STARTSWITH, LINE_ENDSWITH = map(CaselessKeyword, """LINE_CONTAINS LINE_STARTSWITH LINE_ENDSWITH""".split()) # put option for LINE_ENDSWITH. Users may use, I don't presently NOT, AND, OR = map(CaselessKeyword, "NOT AND OR".split()) BEFORE, AFTER, JOIN = map(CaselessKeyword, "BEFORE AFTER JOIN".split()) lpar=Suppress('{') rpar=Suppress('}') keyword = MatchFirst([LINE_CONTAINS, LINE_STARTSWITH, LINE_ENDSWITH, NOT, AND, OR, BEFORE, AFTER, JOIN]) # declaring all keywords and assigning order for all further use phrase_word = ~keyword + (Word(alphanums + '_')) upto_N_words = Group(lpar + 'upto' + pyparsing_common.integer('numberofwords') + 'words' + rpar) upto_N_chars = Group(lpar + 'upto' + pyparsing_common.integer('numberofchars') + 'characters' + rpar) phrase_term = Group(OneOrMore(phrase_word) + ZeroOrMore(((upto_N_words) | ZeroOrMore(upto_N_chars)) + OneOrMore(phrase_word))) | quotedString # changed phrase_word to OneOrMore(phrase_word) to allow multi-word phrases # phrase-term # want to know if there is a way to just say that the phrase_term can contain both types of elements instead of # having to give the exact grammar for it as p_w+upto+p_W phrase_expr = infixNotation(phrase_term, [ ((BEFORE | AFTER | JOIN), 2, opAssoc.LEFT,), # (opExpr, numTerms, rightLeftAssoc, parseAction) (NOT, 1, opAssoc.RIGHT,), (AND, 2, opAssoc.LEFT,), (OR, 2, opAssoc.LEFT),
def get_truncation_language(): language = truncation_tag + nest(ppc.integer(TRUNCATION_POSITION)) language.setParseAction(_handle_trunc_legacy) return language
def create(cls, base_shader_path, base_texture_path): """ Create a Stanford polygon file parser (PLY). :param base_shader_path: :param base_texture_path: :return: """ # Define the base patterns for parsing real = pyparsing_common.real() integer = pyparsing_common.integer() # Define how the header portion begins and ends start_keyword = cls._or(cls.begin_header_keyword, suppress=True) stop_keyword = cls._or(cls.end_header_keyword, suppress=True) # Define the grammar of a comment statement comment_keyword = cls._or(cls.comment_keyword, suppress=True) vertex_shader_comment = Group( comment_keyword + Suppress(CaselessKeyword("VertexShaderFile")) + Word(alphanums + ".-_"))("vertex_shader_file") fragment_shader_comment = Group( comment_keyword + Suppress(CaselessKeyword("FragmentShaderFile")) + Word(alphanums + ".-_"))("fragment_shader_file") texture_comment = Group(comment_keyword + Suppress(CaselessKeyword("TextureFile")) + Word(alphanums + ".-_"))("texture_file") other_comment = comment_keyword + NotAny("TextureFile") + Word( printables + " ") # Define the grammar of a format statement format_keyword = cls._or(cls.format_keyword, suppress=True) format_type = cls._or(cls.format_type_map) format_expr = Group(format_keyword + format_type("file_type") + real("version"))("format") # Define the grammar of properties property_keyword = cls._or(cls.property_keyword, suppress=True) list_keyword = cls._or(cls.list_keyword, suppress=True) property_type = cls._or(cls.data_type_map) psp = property_keyword + property_type("data_type") position_keywords = [cls._or(k) for k in ("x", "y", "z")] property_position = cls._aggregate_property("position", psp, *position_keywords) property_color = Group( And([ Group(psp + MatchFirst((CaselessKeyword("r"), CaselessKeyword("red")))("name")), Group(psp + MatchFirst((CaselessKeyword("g"), CaselessKeyword("green")))("name")), Group(psp + MatchFirst((CaselessKeyword("b"), CaselessKeyword("blue")))("name")), Optional( Group(psp + MatchFirst((CaselessKeyword("a"), CaselessKeyword("alpha")))("name")), ) ]))("color") ambient_keywords = [ cls._or(k) for k in ("ambient_red", "ambient_green", "ambient_blue", "ambient_alpha") ] property_ambient_color = cls._aggregate_property( "ambient_color", psp, *ambient_keywords) diffuse_keywords = [ cls._or(k) for k in ("diffuse_red", "diffuse_green", "diffuse_blue", "diffuse_alpha") ] property_diffuse_color = cls._aggregate_property( "diffuse_color", psp, *diffuse_keywords) specular_keywords = [ cls._or(k) for k in ("specular_red", "specular_green", "specular_blue", "specular_alpha") ] property_specular_color = cls._aggregate_property( "specular_color", psp, *specular_keywords) texture_keywords = [ cls._or(*k) for k in (("s", "u", "tx"), ("t", "v", "ty")) ] property_texture = cls._aggregate_property("texture", psp, *texture_keywords) normal_keywords = [cls._or(k) for k in ("nx", "ny", "nz")] property_normal = cls._aggregate_property("normal", psp, *normal_keywords) power_keywords = [CaselessKeyword("specular_power")] property_specular_power = cls._aggregate_property( "specular_power", psp, *power_keywords) opacity_keywords = [CaselessKeyword("opacity")] property_opacity = cls._aggregate_property("opacity", psp, *opacity_keywords) plp = property_keyword + list_keyword + property_type( "index_type") + property_type("data_type") vertex_index_keywords = [cls._or("vertex_index", "vertex_indices")] property_vertex_index = cls._aggregate_property( "vertex_index", plp, *vertex_index_keywords) material_index_keywords = [ cls._or("material_index", "material_indices") ] property_material_index = cls._aggregate_property( "material_index", plp, *material_index_keywords) # Define the grammar of elements element_keyword = cls._or(cls.element_keyword, suppress=True) element_vertex = Group( element_keyword + CaselessKeyword("vertex")("name") + integer("count") + Group( OneOrMore(property_position | property_color | property_ambient_color | property_diffuse_color | property_specular_color | property_texture | property_normal | property_specular_power | property_opacity))("properties")) element_face = Group(element_keyword + CaselessKeyword("face")("name") + integer("count") + Group(property_vertex_index | property_material_index)("properties")) element_group = element_vertex | element_face declarations = format_expr + \ Group(ZeroOrMore(vertex_shader_comment | fragment_shader_comment | texture_comment | other_comment))("comments") + \ Group(OneOrMore(element_group))("elements") header_grammar = start_keyword + declarations + stop_keyword return cls(header_grammar, base_shader_path, base_texture_path)
alphas, alphanums, Combine, oneOf, Optional, QuotedString, Forward, Group, ZeroOrMore, srange, pyparsing_common as ppc, ) MARK, UNMARK, AT, COLON, QUOTE = map(Suppress, "[]@:'") NUMBER = ppc.integer() FLOAT = ppc.real() STRING = QuotedString('"', multiline=True) | QuotedString("'", multiline=True) WORD = Word(alphas, alphanums + "_:") ATTRIBUTE = Combine(AT + WORD) strBody = Forward() def setBodyLength(tokens): strBody << Word(srange(r"[\0x00-\0xffff]"), exact=int(tokens[0])) return "" BLOB = Combine( QUOTE + Word(nums).setParseAction(setBodyLength) + COLON + strBody + QUOTE