- ! r r )
exclude_charsc ( U S R 5 $ r rq r s r r r ; s qtzz|r c US S:H $ r r] r s r r r A r r zc > U R SSR TR SS5 R 5 R 5 5 - U R 5 5 $ )Nstartrh : ) __setitem__r replacetitler r& )r resnames r r r J sD !-- bgggooc3 7 = = ? E E GH H!&&(
r endrh r r z) rv rw r} namer# alphas alphanumsdbl_quoted_stringr& r%
remove_quotesr r r r Optr
printablesr r/ r' r( r r r r r SkipTotag_body) tagStrxml suppress_LT suppress_GT tagAttrName tagAttrValueopenTagcloseTagr s @r _makeTagsr s, &(##'2++vy5 01K
(--/@@ O Um
:eK(3-$?,$N OPQ
R #w'0AA+
%))+<<]Kd cO
Um
#445KL hsml :;<
#w'0AA+
wt}v-3eDH Vg%&
S1779??ABBhw !
GKHL hj)G r tag_strc [ U S5 $ )a Helper to construct opening and closing tag expressions for HTML,
given a tag name. Matches tags in either upper or lower case,
attributes with namespaces and with quoted or unquoted values.
Example::
text = '| More info at the pyparsing wiki page | '
# make_html_tags returns pyparsing expressions for the opening and
# closing tags as a 2-tuple
a, a_end = make_html_tags("A")
link_expr = a + SkipTo(a_end)("link_text") + a_end
for link in link_expr.search_string(text):
# attributes in the tag (like "href" shown here) are
# also accessible as named results
print(link.link_text, '->', link.href)
prints::
pyparsing -> https://github.com/pyparsing/pyparsing/wiki
Fr r s r make_html_tagsr W s 0 We $$r c [ U S5 $ )zHelper to construct opening and closing tag expressions for XML,
given a tag name. Matches tags only in the given upper/lower case.
Example: similar to :class:`make_html_tags`
Tr r s r
make_xml_tagsr r s Wd ##r any_open_tag
any_close_tagz_:zany tag;z &(?Prk z);zcommon HTML entityc @ [ R UR 5 $ )zRHelper parser action to replace common HTML entities with their special characters)_htmlEntityMapgetentityr s r replace_html_entityr s ahh ''r c \ rS rSrSrSrSrSrg)OpAssoci zrEnumeration of operator associativity
- used in constructing InfixNotationOperatorSpec for :class:`infix_notation`r rR r] N)__name__
__module__ __qualname____firstlineno____doc__LEFTRIGHT__static_attributes__r] r r r r s T
D
Er r base_exprop_listlparrparc " S S[ 5 nSUl [ 5 n[ U[ 5 ( a [ U5 n[ U[ 5 ( a [ U5 n[ U[
5 ( a [ U[
5 ( d U [
X%- U- 5 - nO
XU- U- - n[ U5 GH u pxUS- SS u pp[ U [ 5 ( a [ R U 5 n [ R " [ U 5 n U
S:X aA [ U [ [ 45 ( a [ U 5 S:w a [! S 5 eU u pU
U S
3nOU S
3nS U
s=:: a S:: d
O [! S 5 eU [" R$ [" R& 4; a [! S
5 e[ 5 R) U5 n[ R " [ U5 nU [" R$ L a U
S :X a U" Xi- 5 [
XiS - 5 - nGOZU
S:X aA U b# U" Xi- U- 5 [
XiU- S - 5 - nGO.U" Xf- 5 [
US 5 - nGOU
S:X a4 U" UW
- U- W- U- 5 [
U[+ X- U- U- 5 - 5 - nOU [" R& L a U
S :X aE [ U [, 5 ( d [- U 5 n U" U R. U- 5 [
U U- 5 - nOzU
S:X aC U b" U" Xi- U- 5 [
XiU- S - 5 - nOOU" UU- 5 [
UUS - 5 - nO1U
S:X a+ U" UW
- U- W- U- 5 [
Xm- U- U- U- 5 - nU ( a< [ U [ [ 45 ( a WR0 " U 6 OWR1 U 5 UWU- R3 U5 - nUnGM XV- nU$ )a Helper method for constructing grammars of expressions made up of
operators working in a precedence hierarchy. Operators may be unary
or binary, left- or right-associative. Parse actions can also be
attached to operator expressions. The generated parser will also
recognize the use of parentheses to override operator precedences
(see example below).
Note: if you define a deep operator list, you may see performance
issues when using infix_notation. See
:class:`ParserElement.enable_packrat` for a mechanism to potentially
improve your parser performance.
Parameters:
- ``base_expr`` - expression representing the most basic operand to
be used in the expression
- ``op_list`` - list of tuples, one for each operator precedence level
in the expression grammar; each tuple is of the form ``(op_expr,
num_operands, right_left_assoc, (optional)parse_action)``, where:
- ``op_expr`` is the pyparsing expression for the operator; may also
be a string, which will be converted to a Literal; if ``num_operands``
is 3, ``op_expr`` is a tuple of two expressions, for the two
operators separating the 3 terms
- ``num_operands`` is the number of terms for this operator (must be 1,
2, or 3)
- ``right_left_assoc`` is the indicator whether the operator is right
or left associative, using the pyparsing-defined constants
``OpAssoc.RIGHT`` and ``OpAssoc.LEFT``.
- ``parse_action`` is the parse action to be associated with
expressions matching this operator expression (the parse action
tuple member may be omitted); if the parse action is passed
a tuple or list of functions, this is equivalent to calling
``set_parse_action(*fn)``
(:class:`ParserElement.set_parse_action`)
- ``lpar`` - expression for matching left-parentheses; if passed as a
str, then will be parsed as ``Suppress(lpar)``. If lpar is passed as
an expression (such as ``Literal('(')``), then it will be kept in
the parsed results, and grouped with them. (default= ``Suppress('(')``)
- ``rpar`` - expression for matching right-parentheses; if passed as a
str, then will be parsed as ``Suppress(rpar)``. If rpar is passed as
an expression (such as ``Literal(')')``), then it will be kept in
the parsed results, and grouped with them. (default= ``Suppress(')')``)
Example::
# simple example of four-function arithmetic with ints and
# variable names
integer = pyparsing_common.signed_integer
varname = pyparsing_common.identifier
arith_expr = infix_notation(integer | varname,
[
('-', 1, OpAssoc.RIGHT),
(one_of('* /'), 2, OpAssoc.LEFT),
(one_of('+ -'), 2, OpAssoc.LEFT),
])
arith_expr.run_tests('''
5+3*6
(5+3)*6
-2--11
''', full_dump=False)
prints::
5+3*6
[[5, '+', [3, '*', 6]]]
(5+3)*6
[[[5, '+', 3], '*', 6]]
(5+x)*y
[[[5, '+', 'x'], '*', 'y']]
-2--11
[[['-', 2], '-', ['-', 11]]]
c \ rS rSrSS jrSrg)zinfix_notation.._FBi c @ U R R X5 U/ 4$ r. )r try_parse)selfinstringr doActionss r parseImpl%infix_notation.._FB.parseImpl s II .7Nr r] NT)r r r r r0 r$ r] r r _FBinfix_notation.._FB s r r3 z FollowedBy>r. N rR z@if numterms=3, opExpr must be a tuple or list of two expressionsz termr z6operator must be unary (1), binary (2), or ternary (3)z2operator must indicate right or left associativity)r .)rR .)
FollowedByr r" rv r) r r r rw r _literalStringClassr~ r tupler r5 r r r" r# r' r r r r% setName)r% r& r' r( r3 r lastExprr operDefopExprarityrightLeftAssocpaopExpr1opExpr2 term_namethisExprr s r infix_notationrE s lj
!CL
)C$ ~$ ~
tX & &:dH+E+E uTZ$%6 77 s
T 12 (
-4w->,C)~ fh ' '"66v>F]F3 A: fudm44F q8H V & G")G9E2I!(%(IEQ UV V ',,
!> > QR R"))"4"4Y"?;;w1 W\\ )z 1 2U8Vn;T5U U !% #H$5$@ AE X$5v#>>E !I !$H$7 85&AQ;R RI! w&1G;hF (Yw/AG/Kh/V%WWX Y w}}
,z!&#.. [F h 6 7%@Q:R R !% #H$5$@ AE X$5v#>>E !I !$Hx$7 85 8F#33< !I ! w&1G;hF (,x7'AHLM N "udm,,**B/**2.i(*33I>>} )~ C Jr c ^^^ TR TSS 5 UU4S jm U4S jnU4S jnU4S jn[ [ 5 R S5 R 5 5 n[ 5 [ 5 R
U5 - R S5 n[ 5 R
U5 R S5 n [ 5 R
U5 R S 5 n
U( a? [ [ U5 U- [ U [ U 5 - [ U5 - 5 - U
- 5 n OD[ [ U5 [ U [ U 5 - [ U5 - 5 - [ U
5 - 5 n U R U4S
j5 U R U 4S j5 U R [ [ 5 - 5 U R S 5 $ )
a
(DEPRECATED - use :class:`IndentedBlock` class instead)
Helper method for defining space-delimited indentation blocks,
such as those used to define block statements in Python source code.
Parameters:
- ``blockStatementExpr`` - expression defining syntax of statement that
is repeated within the indented block
- ``indentStack`` - list created by caller to manage indentation stack
(multiple ``statementWithIndentedBlock`` expressions within a single
grammar should share a common ``indentStack``)
- ``indent`` - boolean indicating whether block must be indented beyond
the current level; set to ``False`` for block of left-most statements
(default= ``True``)
A valid block must contain at least one ``blockStatement``.
(Note that indentedBlock uses internal parse actions which make it
incompatible with packrat parsing.)
Example::
data = '''
def A(z):
A1
B = 100
G = A2
A2
A3
B
def BB(a,b,c):
BB1
def BBA():
bba1
bba2
bba3
C
D
def spam(x,y):
def eggs(z):
pass
'''
indentStack = [1]
stmt = Forward()
identifier = Word(alphas, alphanums)
funcDecl = ("def" + identifier + Group("(" + Opt(delimitedList(identifier)) + ")") + ":")
func_body = indentedBlock(stmt, indentStack)
funcDef = Group(funcDecl + func_body)
rvalue = Forward()
funcCall = Group(identifier + "(" + Opt(delimitedList(rvalue)) + ")")
rvalue << (funcCall | identifier | Word(nums))
assignment = Group(identifier + "=" + rvalue)
stmt << (funcDef | assignment | identifier)
module_body = stmt[1, ...]
parseTree = module_body.parseString(data)
parseTree.pprint()
prints::
[['def',
'A',
['(', 'z', ')'],
':',
[['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
'B',
['def',
'BB',
['(', 'a', 'b', 'c', ')'],
':',
[['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
'C',
'D',
['def',
'spam',
['(', 'x', 'y', ')'],
':',
[[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]
Nc > T S TS S & g Nr] )
backup_stacks indentStacks r reset_stack"indentedBlock..reset_stack s &r* Ar c > U[ U 5 : a g [ X5 nUTS :w a! UTS : a [ XS5 e[ XS5 eg )NrI zillegal nestingznot a peer entry)r5 colrC r r r curColrK s r checkPeerIndent&indentedBlock..checkPeerIndent sS A; Q [_ $ B'$Q+<== '9: : %r c h > [ X5 nUTS : a TR U5 g [ XS5 e)NrI znot a subentry)rO appendrC rP s r checkSubIndent%indentedBlock..checkSubIndent s4 Q KO # v & '78 8r c > U[ U 5 : a g [ X5 nT( a UT; d [ XS5 eUTS : a TR 5 g g )Nznot an unindentrI )r5 rO rC r rP s r
checkUnindent$indentedBlock..checkUnindent sM A; Q+ 5 '89 9 KO # OO $r z INDENTrh UNINDENTc J > T ( a T R S5 =( a S $ S $ rH r )rJ s r r indentedBlock.. s -
!!"%.$ITIr c > T" 5 $ r. r] )rW rX cdrL s r r r^ s kmr zindented block)rU r LineEndset_whitespace_charssuppressr r% r' r r r( set_fail_actionignorer )
blockStatementExprrK indentrJ rR rV rY NLr[ PEERUNDENTsmExprrL s
` ` @r
indentedBlockrm Y s~ l Q (+;9
7911%8AAC DBg00 @@
J
J8
TF 7 # #O 4 = =b AD
W
%
%m
4
=
=j
IF
G
u%7 883r7BC
D
Gu%7 883r7BC
D&k
I ;< g 12 ??+ ,,r z/\*(?:[^*]|\*(?!/))*z*/zC style commentzz HTML commentz.*z rest of linez//(?:\\\n|[^\n])*z
// commentzC++ style commentz#.*zPython style comment_builtin_exprsallow_trailing_delimdelimcombineminmaxrp c [ XX#XES9$ )z/(DEPRECATED - use :class:`DelimitedList` class)ro )
DelimitedList)r rq rr rs rt rp s r delimited_listrw s W3 r c g r. r] r] r r
delimitedListry & r c g r. r] r] r r rw rw ) s r c g r. r] r] r r countedArrayr} , r c g r. r] r] r r matchPreviousLiteralr / s r c g r. r] r] r r matchPreviousExprr 2 r c g r. r] r] r r oneOfr 5 s
r c g r. r] r] r r dictOfr 8 s r c g r. r] r] r r originalTextForr ; s r c g r. r] r] r r
nestedExprr > s r c g r. r] r] r r makeHTMLTagsr A r~ r c g r. r] r] r r makeXMLTagsr D s r c g r. r] r] r r replaceHTMLEntityr G r r c g r. r] r] r r
infixNotationr J rz r r. )FTFr2 ),FNN)a
html.entitieshtmlrm sysr~ rh r coreutilr r r r r Optionalr* r? rJ Unionr r) boolr r r r r r r r r Tupler r __annotations__r# r r r' r r entitieshtml5itemsrstripr r r common_html_entityr Enumr InfixNotationOperatorArgTyper ParseActionInfixNotationOperatorSpecListrE rm r c_style_comment html_commentleave_whitespace rest_of_linedbl_slash_commentcpp_style_commentjava_style_commentpython_style_commentvarsvaluesrv rn rw opAssoc
anyOpenTag anyCloseTagcommonHTMLEntity
cStyleComment htmlComment
restOfLinedblSlashCommentcppStyleCommentjavaStyleCommentpythonStyleCommentrv ry r} r r r r r r r r r r )kvs 00r r s
049I /3 9I
9Ioom,9I __]
+ 9I
9Ix = B!m !
!L { {
$c)
*{{ { {
{ { {|%/ %/} %/ %/R ,02EI2
2$(2>B22jA- AM A m
H ),(+.2!. @ !.
@ #}$ %@ #}$ %@ __]
+@ @
@ @F (0}(3- 7 t%
3
%
&%
=- '(%6$
3
%
&$
=- '($ ,T!"++I6 m 04}}/B/B/H/H/JK/Jtq!((3-"/JK>CHH^,DDtKLUU
(
d %3eM3$6 7}c?Q9R RSS " $ $ &
$
$ '/sm&.sm n n
+
,n ]"
#n ]"
# n
nb ;?b L-` % 784?@II $'(11.A &U|,,.77G ./88 F 1
!"T),==
( P& $ V}--.DE 0 v}}' !*Q
">A']# (+ $ $ "'
]"
# m# $
"
%
##% ) - ! - ! - ! () * %& ' & ' #$ % + .! " - ! %& ' .! " Q L@ 's Q&Q!<Q!