ãڊ d Z dZdZdZddlZddlmZ ddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlmZ ddlmZ ddlZdd lmZ dd
lmZ dd lmZ n# e$ r dd lmZ Y nw xY w dd
l m Z n# e$ r dd
l m Z Y nw xY w ddl m Z ddl m!Z!m"Z" n# e$ r ddl
m Z ddl
m!Z!m"Z" Y nw xY w ddl
m#Z$ n # e$ r ddl%m#Z$ n
# e$ r dZ$Y nw xY wY nw xY w ddlm&Z& n# e$ r G d d Z&Y nw xY w e& Z'de'_ de'_( e& Z)de)_ de)_* de)_+ de)_, de)_- de)_. d e/e) D e)_0 d Z1e1e)_2 g dZ3 e4e j5 dd Z6e6d dk Z7e7r e j8 Z9e:Z;ee:Z?e@eAeBeCeDe4eEeFeGeHeIg ZJnTe jK Z9eLZMd Z?g ZJddlNZNd O D ]-ZP eJQ eReNeP ## eS$ r Y *w xY w eTd eMd D ZUd ZVejW ejX z ZYd!ZZeZd"z Z[eYeZz Z\ e d?eh Zt G d@ dAet Zu G dB dCet Zv G dD dEev Zw G dF dGev Zx G dH dIev Zy G dJ dKey ZzeyZ{eyet_| G dL dMev Z} G dN dOey Z~ G dP dQe} Z G dR dSev Z G dT dUev Z G dV dWe Z G dX dYe Z G dZ d[ev Z G d\ d]ev Z G d^ d_ev Z G d` daev Z G db dcev Z G dd dee Z G df dge Z G dh die Z G dj dke Z G dl dme Z G dn doe Z G dp dqe Z G dr dset Z G dt due Z G dv dwe Z G dx dye Z G dz d{e Z G d| d}et Z G d~ de Z G d de Z G d de Z G d de Z G d de Z G d de Z G d deh Z G d de Z G d de Z G d de Z G d de Z G d de Z G d de Z G d de Z G d de Z G d deh Zd Zd dZd dZd Zd Zd Zd Zd dZd Zd dZd Zd Z ew d Z e d Z e d Z e d Z e d Z ee]dd< d Z ed d Z ed d Zeez ez edd z Z ee ed z ez Z eyd ed d z e eeez d z dz Zd Zd Zd Zd Zd Z edÄ Z edĄ Z edŦ edƦ fdDŽZdȄ ZdɄ Zdʄ Z eh e_ d d˄Z e& Z eh e_ eh e_ ed̦ edͦ fd΄ZeZ e edϦ dz dѦ Z e edҦ dz dԦ Z e edϦ dz edҦ dz z dզ Z e e{d֦ eԠ z dצ ZdddeԠ fdZd dلZ edڦ Z edۦ Z e eeYe\dz dݦ \ ZZ e edޠO dߦ Z edd^ eޠ z dz d Zd Z e ed dz d Z ed d Z ed d Z ed d Z e ed dz ez d Z eZ ed d Z e e ee`d e ed eyd z e z z d Z e eeԠ ez d$ d Z G d d Z G d deh Z G d deh Z G d de Zej j j ej j j z ej j j z ej _ e7r eedej eedej eed ej eedej eedej eedej eej dej j eej dej j eej dej j eedej eedej eed ej G d
d Ze d k r e~d
Z e~d Z eeYe\dz Z eedd eŦ Z e ee d Zdez Z eedd eŦ Z e ee d Z ed ed z ez ed z Z e
d ej
d ej
d ej
d ddlZej eĐej ej
d dS dS (! a
pyparsing module - Classes and methods to define and execute parsing grammars
=============================================================================
The pyparsing module is an alternative approach to creating and
executing simple grammars, vs. the traditional lex/yacc approach, or the
use of regular expressions. With pyparsing, you don't need to learn
a new syntax for defining grammars or matching expressions - the parsing
module provides a library of classes that you use to construct the
grammar directly in Python.
Here is a program to parse "Hello, World!" (or any greeting of the form
``", !"``), built up using :class:`Word`,
:class:`Literal`, and :class:`And` elements
(the :class:`'+'` operators create :class:`And` expressions,
and the strings are auto-converted to :class:`Literal` expressions)::
from pip._vendor.pyparsing import Word, alphas
# define grammar of a greeting
greet = Word(alphas) + "," + Word(alphas) + "!"
hello = "Hello, World!"
print (hello, "->", greet.parseString(hello))
The program outputs the following::
Hello, World! -> ['Hello', ',', 'World', '!']
The Python representation of the grammar is quite readable, owing to the
self-explanatory class names, and the use of '+', '|' and '^' operators.
The :class:`ParseResults` object returned from
:class:`ParserElement.parseString` can be
accessed as a nested list, a dictionary, or an object with named
attributes.
The pyparsing module handles some of the problems that are typically
vexing when writing text parsers:
- extra or missing whitespace (the above program will also handle
"Hello,World!", "Hello , World !", etc.)
- quoted strings
- embedded comments
Getting Started -
-----------------
Visit the classes :class:`ParserElement` and :class:`ParseResults` to
see the base classes that most other pyparsing
classes inherit from. Use the docstrings for examples of how to:
- construct literal match expressions from :class:`Literal` and
:class:`CaselessLiteral` classes
- construct character word-group expressions using the :class:`Word`
class
- see how to create repetitive expressions using :class:`ZeroOrMore`
and :class:`OneOrMore` classes
- use :class:`'+'`, :class:`'|'`, :class:`'^'`,
and :class:`'&'` operators to combine simple expressions into
more complex ones
- associate names with your parsed results using
:class:`ParserElement.setResultsName`
- access the parsed data, which is returned as a :class:`ParseResults`
object
- find some helpful expression short-cuts like :class:`delimitedList`
and :class:`oneOf`
- find more useful common expressions in the :class:`pyparsing_common`
namespace class
z2.4.7z30 Mar 2020 00:43 UTCz*Paul McGuire N)ref)datetime)
itemgetter)wraps)contextmanager) filterfalse) ifilterfalse)RLock)Iterable)MutableMappingMapping) OrderedDict)SimpleNamespacec e Zd ZdS )r N)__name__
__module__ __qualname__ /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el9.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/pyparsing.pyr r s r r aA
A cross-version compatibility configuration for pyparsing features that will be
released in a future version. By setting values in this configuration to True,
those features can be enabled in prior versions for compatibility development
and testing.
- collect_all_And_tokens - flag to enable fix for Issue #63 that fixes erroneous grouping
of results names when an And expression is nested within an Or or MatchFirst; set to
True to enable bugfix released in pyparsing 2.3.0, or False to preserve
pre-2.3.0 handling of named results
Ta
Diagnostic configuration (all default to False)
- warn_multiple_tokens_in_named_alternation - flag to enable warnings when a results
name is defined on a MatchFirst or Or expression with one or more And subexpressions
(only warns if __compat__.collect_all_And_tokens is False)
- warn_ungrouped_named_tokens_in_collection - flag to enable warnings when a results
name is defined on a containing expression with ungrouped subexpressions that also
have results names
- warn_name_set_on_empty_Forward - flag to enable warnings whan a Forward is defined
with a results name, but has no contents defined
- warn_on_multiple_string_args_to_oneof - flag to enable warnings whan oneOf is
incorrectly called with multiple str arguments
- enable_debug_on_named_expressions - flag to auto-enable debug on all subsequent
calls to ParserElement.setName()
Fc f g | ].}| d s| d ,|/S )enable_warn_
startswith).0nms r
r s> iiibbmmI6N6NiRTR_R_`gRhRhiriiir c f dt _ dt _ dt _ dt _ d S NT)__diag__)warn_multiple_tokens_in_named_alternation)warn_ungrouped_named_tokens_in_collection warn_name_set_on_empty_Forward%warn_on_multiple_string_args_to_oneofr r r _enable_all_warningsr& s( 9=H69=H6.2H+59H222r )t __version____versionTime__
__author__
__compat__r! AndCaselessKeywordCaselessLiteral
CharsNotInCombineDictEachEmpty
FollowedByForward
GoToColumnGroupKeywordLineEnd LineStartLiteral
PrecededBy
MatchFirstNoMatchNotAny OneOrMoreOnlyOnceOptionalOrParseBaseExceptionParseElementEnhanceParseExceptionParseExpressionParseFatalException ParseResultsParseSyntaxException
ParserElement QuotedStringRecursiveGrammarExceptionRegexSkipTo StringEnd StringStartSuppressTokenTokenConverterWhiteWordWordEnd WordStart
ZeroOrMoreChar alphanumsalphas
alphas8bit anyCloseTag
anyOpenTag
cStyleCommentcolcommaSeparatedListcommonHTMLEntity countedArraycppStyleCommentdblQuotedStringdblSlashComment
delimitedListdictOfdowncaseTokensemptyhexnums htmlCommentjavaStyleCommentlinelineEnd lineStartlineno makeHTMLTags makeXMLTagsmatchOnlyAtColmatchPreviousExprmatchPreviousLiteral
nestedExprnullDebugActionnumsoneOfopAssocoperatorPrecedence
printablespunc8bitpythonStyleComment quotedString removeQuotesreplaceHTMLEntity replaceWith
restOfLinesglQuotedStringsrange stringEnd stringStarttraceParseAction
unicodeString upcaseTokens
withAttribute
indentedBlockoriginalTextForungroup
infixNotation locatedExpr withClass
CloseMatchtokenMappyparsing_commonpyparsing_unicode unicode_setconditionAsParseActionre c L t | t r| S t | S # t $ rq t | t j d }t d }| d | | cY S w xY w)a Drop-in replacement for str(obj) that tries to be Unicode
friendly. It first tries str(obj). If that fails with
a UnicodeEncodeError, then it tries unicode(obj). It then
< returns the unicode object | encodes it with the default
encoding | ... >.
xmlcharrefreplacez&#\d+;c l dt t | d dd dd z S )Nz\ur )hexintts r z_ustr.. s. C!QrT
OO8L8LQRR8P0P r )
isinstanceunicodestrUnicodeEncodeErrorencodesysgetdefaultencodingrM setParseActiontransformString)objret
xmlcharrefs r _ustrr s c7 # # J
3 s88O! 3 3 3#,,%%c&<&>&>@STTC y))J % %&P&P Q Q Q --c22 2 2 2 3s ( A8B#"B#z6sum len sorted reversed list tuple set any all min maxc # K | ]}|V d S Nr )r ys r r s" ++Qq++++++r c d}d d D }t || D ]\ }}| || } | S )z/Escape &, <, >, ", ', etc. in a string of data.z&><"'c 3 & K | ] }d |z dz V
dS )&;Nr )r ss r r z _xml_escape.. s* GGA#'C-GGGGGGr zamp gt lt quot apos)splitzipreplace)data from_symbols
to_symbolsfrom_to_s r _xml_escaper s` LGG)>)D)D)F)FGGGJ,
33 ( (
s||E3'' Kr
0123456789 ABCDEFabcdef\ c # 6 K | ]}|t j v|V d S r )string
whitespacer cs r r r s/ OO1AV=N4N4NQ4N4N4N4NOOr c ||nd|rt nt t t fd }|S )Nz failed user-defined conditionc V t | || s
| | d S r )bool)r lr exc_typefnmsgs r paz"conditionAsParseAction..pa% s= BBq!QKK &(1a%% % & &r )rG rE _trim_arityr )r messagefatalr r r s ` @@r r r si (''.MC&+?"" H R B
2YY& & & & & & Y& Ir c P e Zd ZdZd dZed Zd Zd Zd Z d
d
Z
d Z dS )rC z7base exception class for all parsing runtime exceptionsr Nc t || _ ||| _ d| _ n|| _ || _ || _ |||f| _ d S Nr )locr pstr
parserElementargs)selfr r r elems r __init__zParseBaseException.__init__0 sF ;DHDIIDH DI !3$ r c F | |j |j |j |j S )z
internal factory method to simplify creating one type of ParseException
from another - avoids having __init__ signature conflicts among subclasses
)r r r r )clspes r _from_exceptionz"ParseBaseException._from_exception; s# s27BFBFB,<===r c |dk rt | j | j S |dv rt | j | j S |dk rt | j | j S t | )zsupported attributes by name are:
- lineno - returns the line number of the exception text
- col - returns the column number of the exception text
- line - returns the line containing the exception text
rq )r` columnrn )rq r r r` rn AttributeError)r anames r __getattr__z ParseBaseException.__getattr__C sn H $(DI.. .
'
'
'tx++ +
f__$),, , '' 'r c | j rT| j t | j k rd}n6d| j | j | j dz z dd }nd}d| j || j | j | j fz S )Nz, found end of textz
, found %rr z\\\r z%%s%s (at char %d), (line:%d, col:%d))r r lenr r rq r )r foundstrs r __str__zParseBaseException.__str__R s 9 x3ty>>))0 (49TXdhl5J+K KTTUZ\`aaH7Hh$+t{KL Mr c t | S r r r s r __repr__zParseBaseException.__repr__\ T{{r >! > [>
(
(
( M M M ; ; ; ; ;r rC c * e Zd ZdZedd ZdS )rE a:
Exception thrown when parse expressions don't match class;
supported attributes by name are:
- lineno - returns the line number of the exception text
- col - returns the column number of the exception text
- line - returns the line containing the exception text
Example::
try:
Word(nums).setName("integer").parseString("ABC")
except ParseException as pe:
print(pe)
print("column: {}".format(pe.col))
prints::
Expected integer (at char 0), (line:1, col:1)
column: 1
c ddl }|t j }g }t | t r=| | j | d| j dz
z dz | d t | j
| |dk r|| | j | }t }t || d D ]8\ }}|d }|j dd } t | t" rm|j j d vrM| |v rR| | t | }
| d
|
j |
j
| n| Ct | }
| d |
j |
j
n?|j } | j d v r| d
| j |dz }|s n:d | S )ap
Method to take an exception and translate the Python internal traceback into a list
of the pyparsing expressions that caused the exception to be raised.
Parameters:
- exc - exception raised during parsing (need not be a ParseException, in support
of Python exceptions that might be raised in a parse action)
- depth (default=16) - number of levels back in the stack trace to list expression
and function names; if None, the full stack trace names will be listed; if 0, only
the failing input line, marker, and exception string will be shown
Returns a multi-line string listing the ParserElements and/or function names in the
exception's stack trace.
Note: the diagnostic output will include string representations of the expressions
that failed to parse. These representations will be more helpful if you use `setName` to
give identifiable names to your expressions. Otherwise they will use the default string
forms, which may be cryptic to read.
explain() is only supported under Python 3.
r N r ^z{0}: {1})contextr ) parseImpl
_parseNoCachez
{0}.{1} - {2}z{0}.{1})wrapperzz{0}
)inspectr getrecursionlimitr rC appendrn r` formatr r getinnerframes
__traceback__set enumeratef_localsgetrJ f_codeco_nameaddr r ) excdepthr r callersseenifffrmf_self self_typecodes r explainzParseException.explain sN 0 =)++E c- . . 2 JJsx JJscgk*S0 1 1 1
:$$T#YY%7==>>> 199 ,,S->,NNG55D"7E677#344
2e ))&$77 fm44 ;z)1OOO ~~ HHV$$$ $V IJJ 5 5i6J6?6H6< > > ? ? ? ? ' $V IJJy / / 0D090B D D E E E E :D|'>>> JJu||DL 9 9:::
E yy~~ r N)r )r r r r staticmethodr% r r r rE rE k sD , B B B \B B B r rE c e Zd ZdZdS )rG znuser-throwable exception thrown when inconsistent parse content
is found; stops all parsing immediatelyNr r r r r r r rG rG s 2 2Dr rG c e Zd ZdZdS )rI zjust like :class:`ParseFatalException`, but thrown internally
when an :class:`ErrorStop` ('-' operator) indicates
that parsing is to stop immediately because an unbacktrackable
syntax error has been found.
Nr( r r r rI rI s
Dr rI c e Zd ZdZd Zd ZdS )rL ziexception thrown by :class:`ParserElement.validate` if the
grammar could be improperly recursive
c || _ d S r parseElementTracer parseElementLists r r z"RecursiveGrammarException.__init__ s !1 r c d| j z S )Nz RecursiveGrammarException: %sr, r s r r z!RecursiveGrammarException.__str__ s .1GGGr N)r r r r r r r r r rL rL sA 2 2 2H H H H Hr rL c & e Zd Zd Zd Zd Zd ZdS )_ParseResultsWithOffsetc ||f| _ d S r tup)r p1p2s r r z _ParseResultsWithOffset.__init__ s 8r c | j | S r r4 r r s r __getitem__z#_ParseResultsWithOffset.__getitem__ s x{r c 6 t | j d S Nr )reprr5 r s r r z _ParseResultsWithOffset.__repr__ s DHQK r c . | j d |f| _ d S r< r4 r9 s r setOffsetz!_ParseResultsWithOffset.setOffset s HQK#r N)r r r r r: r r? r r r r2 r2 sP ! ! !$ $ $ $ $r r2 c l e Zd ZdZd2dZddddefdZd ZefdZd Z d Z
d
Z d Z e Z
d Zd
Zd Zd Zd Zer eZ eZ eZneZ eZ eZ d Zd Zd Zd Zd Zd3dZ d Z d Z d Z d Z d Z!d Z"d Z#d Z$d Z%d Z&d4d"Z'd# Z(d$ Z)d% Z*d5d'Z+d( Z,d) Z-d6d+Z.d, Z/d- Z0d. Z1d/ Z2d0 Z3e4d3d1 Z5dS )7rH aS Structured parse results, to provide multiple means of access to
the parsed data:
- as a list (``len(results)``)
- by list index (``results[0], results[1]``, etc.)
- by attribute (``results.`` - see :class:`ParserElement.setResultsName`)
Example::
integer = Word(nums)
date_str = (integer.setResultsName("year") + '/'
+ integer.setResultsName("month") + '/'
+ integer.setResultsName("day"))
# equivalent form:
# date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
# parseString returns a ParseResults object
result = date_str.parseString("1999/12/31")
def test(s, fn=repr):
print("%s -> %s" % (s, fn(eval(s))))
test("list(result)")
test("result[0]")
test("result['month']")
test("result.day")
test("'month' in result")
test("'minutes' in result")
test("result.dump()", str)
prints::
list(result) -> ['1999', '/', '12', '/', '31']
result[0] -> '1999'
result['month'] -> '12'
result.day -> '31'
'month' in result -> True
'minutes' in result -> False
result.dump() -> ['1999', '/', '12', '/', '31']
- day: 31
- month: 12
- year: 1999
NTc l t || r|S t | }d|_ |S r )r object__new___ParseResults__doinit)r toklistnameasListmodalretobjs r rC zParseResults.__new__! s6 gs # # N $$
r c n | j rd| _ d | _ d | _ i | _ || _ || _ |g } ||t r|d d | _ n. ||t rt
| | _ n|g| _ t | _
||r|s
d| j |< ||t rt | }|| _ ||t d t t f r|d dg fv s ||t r|g}|rl ||t r&t! t |j d | |< n&t! t |d d | |< || | _ d S |d | |< d S # t" t$ t& f$ r || |< Y d S w xY wd S d S d S )NFr r )rD _ParseResults__name_ParseResults__parent_ParseResults__accumNames_ParseResults__asList_ParseResults__modallist_ParseResults__toklist_generatorTypedict_ParseResults__tokdictr r r
basestringrH r2 KeyError TypeError
IndexError)r rE rF rG rH r s r r zParseResults.__init__* s = $ !DM DK DM "D "DM DL z'4((
+!(G^44
+!%g ") !VVDN
,*+!$'z$$$
# T{{ DK JwdZ(FGG
-GX\^`bdWeLeLe :gz22 ( &iG
-!z'<88 Z%<\'J[=\=\^_%`%`T
%<\'RS*=U=UWX%Y%YT
(,DJ%%%-%,QZT
$i< - - -%,T
-% MfLes F F.-F.c t |t t f r
| j | S || j vr| j | d d S t
d | j | D S )Nr r c g | ]
}|d S r r )r vs r r z,ParseResults.__getitem__..X s $E$E$EaQqT$E$E$Er )r r slicerQ rM rT rH r9 s r r: zParseResults.__getitem__Q so a#u & & G>!$ $)))~a(,Q//#$E$E4>!3D$E$E$EFFFr c ||t r<| j |t |gz | j |< |d }nh ||t t
f r
|| j |< |}nC| j |t t |d gz | j |< |} ||t rt | |_ d S d S r< )
r2 rT r rP r r] rQ rH wkrefrL )r kr\ r subs r __setitem__zParseResults.__setitem__Z s :a0 1 1 $ 2 21dff = = CDN1 A$CC
ZC<
(
( !DN1 CC $ 2 21dff = =AXYZ\]A^A^@_ _DN1 C :c< ( ( ' ;;CLLL ' 'r c t |t t f rt | j }| j |= t |t r |dk r||z
}t ||dz }t t
| | }| | j
D ]<\ }}|D ]4}t | D ]"\ }\ }} t || | |k z
||< #5=d S | j |= d S Nr r )
r r r] r rQ rP rangeindicesreverserT itemsr r2 )
r r mylenremovedrF occurrencesjr` valuepositions
r __delitem__zParseResults.__delitem__g s9 a#u & & "''Eq! !S!!
$q55JA!QUOO5!))E"2"2344G OO %)^%9%9%;%;
c
c!k c cA09+0F0F c c,,E8)@T\_`T`Ha)b)b Acc
c
c
q!!!r c || j v S r )rT )r r` s r __contains__zParseResults.__contains__| s DN""r c * t | j S r )r rQ r s r __len__zParseResults.__len__ s 4>"""r c | j S r rQ r s r __bool__zParseResults.__bool__ s &&'r c * t | j S r iterrQ r s r __iter__zParseResults.__iter__ s DN###r c < t | j d d d S Nr rx r s r __reversed__zParseResults.__reversed__ s DN44R4()))r c t | j d r| j S t | j S )Niterkeys)hasattrrT r ry r s r _iterkeyszParseResults._iterkeys s: 4>: . . (>**,, ,'' 'r c D fd D S )Nc 3 ( K | ] }| V
d S r r r r` r s r r z+ParseResults._itervalues.. s' 22AQ222222r r r s `r _itervalueszParseResults._itervalues s' 2222 !1!12222r c D fd D S )Nc 3 , K | ]}|| fV d S r r r s r r z*ParseResults._iteritems.. s+ 77DG 777777r r r s `r
_iteritemszParseResults._iteritems s' 7777dnn&6&67777r c D t | S )zVReturns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x).)rP r r s r keyszParseResults.keys s
(( (r c D t | S )zXReturns all named result values (as a list in Python 2.x, as an iterator in Python 3.x).)rP
itervaluesr s r valueszParseResults.values s ))** *r c D t | S )zfReturns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x).)rP iteritemsr s r rh zParseResults.items s (()) )r c * t | j S )zSince keys() returns an iterator, this method is helpful in bypassing
code that looks for the existence of any defined results names.)r rT r s r haskeyszParseResults.haskeys s DN###r c 2 |sdg}| D ]'\ }}|dk r |d |f}t d|z t |d t s t | dk s
|d | v r|d }| | }| |= |S |d }|S )a
Removes and returns item at specified index (default= ``last``).
Supports both ``list`` and ``dict`` semantics for ``pop()``. If
passed no argument or an integer argument, it will use ``list``
semantics and pop tokens from the list of parsed tokens. If passed
a non-integer argument (most likely a string), it will use ``dict``
semantics and pop the corresponding value from any defined results
names. A second default return value argument is supported, just as in
``dict.pop()``.
Example::
def remove_first(tokens):
tokens.pop(0)
print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
label = Word(alphas)
patt = label("LABEL") + OneOrMore(Word(nums))
print(patt.parseString("AAB 123 321").dump())
# Use pop() in a parse action to remove named result (note that corresponding value is not
# removed from list form of results)
def remove_LABEL(tokens):
tokens.pop("LABEL")
return tokens
patt.addParseAction(remove_LABEL)
print(patt.parseString("AAB 123 321").dump())
prints::
['AAB', '123', '321']
- LABEL: AAB
['AAB', '123', '321']
r defaultr z-pop() got an unexpected keyword argument '%s'r )rh rW r r r )r r kwargsr` r\ indexr defaultvalues r popzParseResults.pop s J 4DLLNN U UDAqI~~ Q| ORS STTT tAw $ $ t99>>7d??GEu+CU J 7L r c || v r| | S |S )a[
Returns named result matching the given key, or if there is no
such name, then returns the given ``defaultValue`` or ``None`` if no
``defaultValue`` is specified.
Similar to ``dict.get()``.
Example::
integer = Word(nums)
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
result = date_str.parseString("1999/12/31")
print(result.get("year")) # -> '1999'
print(result.get("hour", "not specified")) # -> 'not specified'
print(result.get("hour")) # -> None
r )r key defaultValues r r zParseResults.get s $ $;;9 r c | j || | j D ]7\ }}t | D ]"\ }\ }}t ||||k z ||< #8dS )a
Inserts new element at location index in the list of parsed tokens.
Similar to ``list.insert()``.
Example::
print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
# use a parse action to insert the parse location in the front of the parsed results
def insert_locn(locn, tokens):
tokens.insert(0, locn)
print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
N)rQ insertrT rh r r2 )r r insStrrF rk r` rm rn s r r zParseResults.insert s
eV,,,!% !5!5!7!7 _ _ D+(1+(>(>
_
_$$E8!8HW\L\@]!^!^ A
_ _ _r c : | j | dS )a
Add single element to end of ParseResults list of elements.
Example::
print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
# use a parse action to compute the sum of the parsed integers, and add it to the end
def append_sum(tokens):
tokens.append(sum(map(int, tokens)))
print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
N)rQ r )r items r r zParseResults.append s
d#####r c t |t r| | dS | j | dS )a
Add sequence of elements to end of ParseResults list of elements.
Example::
patt = OneOrMore(Word(alphas))
# use a parse action to append the reverse of the matched strings, to make a palindrome
def make_palindrome(tokens):
tokens.extend(reversed([t[::-1] for t in tokens]))
return ''.join(tokens)
print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
N)r rH __iadd__rQ extend)r itemseqs r r zParseResults.extend/ sJ g| , , + MM' " " " " " N ! !' * * * * *r c L | j dd= | j dS )z7
Clear all elements and results names.
N)rQ rT clearr s r r zParseResults.clearB s,
N111 r c 6 | | S # t $ r Y dS w xY wr )rV r rF s r r zParseResults.__getattr__I s3 : 22 s
c 8 | }||z
}|S r copy)r otherr s r __add__zParseResults.__add__O s iikk u
r c |j rt | j fd|j }fd|D }|D ]?\ }}|| |< t |d t
rt
| |d _ @| xj |j z
c_ | j |j | S )Nc | dk rn| z S r< r )aoffsets r r z'ParseResults.__iadd__..W s AEE&&q6z r c n g | ]1\ }}|D ])}|t |d |d f*2S r r )r2 )r r` vlistr\ addoffsets r r z)ParseResults.__iadd__..Y sj I I I"*!U% I I=> !"9!A$ !A$"P"P Q I I I Ir r )
rT r rQ rh r rH r_ rL rM update)r r
otheritemsotherdictitemsr` r\ r r s @@r r zParseResults.__iadd__T s ? 0 ((FAAAAI ..00J I I I I.8 I I IN&
0
01Q adL11 0$)$KKAaDM %/) !3444 r c j t |t r|dk r| S || z S r< )r r r r r s r __radd__zParseResults.__radd__d s6 eS ! ! eqjj99;; 4< r c \ dt | j dt | j dS )N(, ))r= rQ rT r s r r zParseResults.__repr__l s/ !$. 1 1 1 143G3G3G3GHHr c V dd d | j D z dz S )N[r c 3 | K | ]7}t |t rt | nt | V 8d S r )r rH r r= )r r s r r z'ParseResults.__str__..p sC l lXY:a +F+F SuQxxxDQRGG l l l l l lr ])r rQ r s r r zParseResults.__str__o s2 TYY l l]a]k l l llllorrrr r c g }| j D ]j}|r|r| | t |t r|| z
}H| t | k|S r )rQ r r rH
_asStringListr )r sepoutr s r r zParseResults._asStringListr s N ( (D
s
3$ --
(t))+++
5;;''''
r c $ d | j D S )ax
Returns the parse results as a nested list of matching tokens, all converted to strings.
Example::
patt = OneOrMore(Word(alphas))
result = patt.parseString("sldkj lsdkj sldkj")
# even though the result prints in string-like form, it is actually a pyparsing ParseResults
print(type(result), result) # -> ['sldkj', 'lsdkj', 'sldkj']
# Use asList() to create an actual list
result_list = result.asList()
print(type(result_list), result_list) # -> ['sldkj', 'lsdkj', 'sldkj']
c d g | ]-}t |t r| n|.S r )r rH rG )r ress r r z'ParseResults.asList.. s3 aaa3
3 = =F
3aaar ru r s r rG zParseResults.asList} s baRVR`aaaar c t r| j }n| j }fdt fd | D S )a
Returns the named parse results as a nested dictionary.
Example::
integer = Word(nums)
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
result = date_str.parseString('12/31/1999')
print(type(result), repr(result)) # -> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
result_dict = result.asDict()
print(type(result_dict), repr(result_dict)) # -> {'day': '1999', 'year': '12', 'month': '31'}
# even though a ParseResults supports dict-like access, sometime you just need to have a dict
import json
print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
c t | t r6| r| S fd| D S | S )Nc & g | ]
} | S r r )r r\ toItems r r z7ParseResults.asDict..toItem.. s! 333!FF1II333r )r rH r asDict)r r s r r z#ParseResults.asDict..toItem sR #|,,
;;== 4 ::<<'3333s3333
r c 3 8 K | ]\ }}| | fV d S r r )r r` r\ r s r r z&ParseResults.asDict.. s3 99tq!Qq N999999r )PY_3rh r rS )r item_fnr s @r r zParseResults.asDict sa ( %jGGnG 9999wwyy999999r c t | j }t | j |_ | j |_ |j | j | j |_ |S )zG
Returns a new copy of a :class:`ParseResults` object.
) rH rQ rS rT rh rL rM r rK )r r s r r zParseResults.copy sa 4>** T^ 1 1 3 344
} 1222[
r Fc d}g }t d | j D }|dz }|sd}d}d}d} ||} n| j r| j } | s|rdS d} |||d| dgz
}t | j D ]\ }
} t
| t rL|
|v r'|| ||
|o|du || gz
}E|| d|o|du || gz
}fd} |
|v r||
} | s|ryd} t t | }
|||d| d|
d | dg z
}|||d | dgz
}d | S )
z
(Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
r
c 3 : K | ]\ }}|D ]}|d |fV dS r Nr )r r` r r\ s r r z%ParseResults.asXML.. sV * *
E#(* * Q4) * * * * * * *r r NITEM<> K | ]\ }}t | |fV d S r )r r r` r\ s r r z$ParseResults.dump..G s0 D Dtq!A{ D D D D D Dr r z- : r )r full include_list_depthc 3 @ K | ]}t |t V d S r )r rH )r vvs r r z$ParseResults.dump..S s, AAbZL11AAAAAAr z
%s%s[%d]:
%s%s%s)
r r rG r sortedrh r rH dumpr= anyr r ) r r r r r r NLrh r` r\ r r s r r zParseResults.dump) s *
JJvdkkmm 4 44 5 5 5 5 JJrNNN ! H||~~
H D Dtzz|| D D DDD !
,
,DAq '
2JJvvv
JKKK!!\22 , 1 JJqvvV$Uajpstjtv'u'u v v v v JJuQxx 0 0 0 0
477++++
, AADAAAAA
H &q\\ H HEAr!"l33 H
#8F=AV_<=GG6IMQ]KQTU: =D =W =W `_ module.
Accepts additional positional or keyword args as defined for
`pprint.pprint `_ .
Example::
ident = Word(alphas, alphanums)
num = Word(nums)
func = Forward()
term = ident | num | Group('(' + func + ')')
func <<= ident + Group(Optional(delimitedList(term)))
result = func.parseString("fna a,b,(fnb c,d,200),100")
result.pprint(width=40)
prints::
['fna',
['a',
'b',
['(', 'fnb', ['c', 'd', '200'], ')'],
'100']]
N)pprintrG )r r r s r r zParseResults.pprintj s2 2
dkkmm5d555f55555r c | j | j | j d ur| pd | j | j ffS r )rQ rT r rL rM rK r s r __getstate__zParseResults.__getstate__ sN $$&& d*>t}}F$" r c |d | _ |d \ | _ }}| _ i | _ | j | |t | | _ d S d | _ d S rd )rQ rT rK rM r r_ rL )r stater inAccumNamess r __setstate__zParseResults.__setstate__ sc q9>q6\4; ... ? !#JJDMMM DMMMr c 6 | j | j | j | j fS r )rQ rK rN rO r s r __getnewargs__zParseResults.__getnewargs__ s ~t{DM4<GGr c ~ t t | t | z S r )r r rP r r s r r zParseResults.__dir__ s) 4::diikk!2!222r c d } | g }| D ]P\ }}t |t r|| || z
}5| | |g| || z
}Q| | |g| }|S )z
Helper classmethod to construct a ParseResults from a dict, preserving the
name-value relations as results names. If an optional 'name' argument is
given, a nested ParseResults will be returned
c t | t r t | t t f S t | t
S # t $ r Y dS w xY wNF)ry r r r bytesrU Exception)r s r is_iterablez+ParseResults.from_dict..is_iterable sj
;S ; )#U| < <<< )#z : :::
uu
s A
AArF )rF rG )rh r r
from_dict)r r rF r r r` r\ s r r
zParseResults.from_dict s ; ; ; c"ggKKMM ? ?DAq!W%%
?s}}QQ}///ssA3Q{{1~~>>>> #se$'''C
r )NNTTr r )NFr T)r TTr )6r r r r rC r r r: rb ro rq rs rv __nonzero__rz r} r r r r r r rh r r r r r r r r r r r r r r r r r rG r r r r r r r r r r r r r
r r r rH rH sD ) )T $$t4T^ %- %- %- %-NG G G ,6 ' ' ' '" " "*# # ## # #( ( (K$ $ $* * *( ( ( 3 3 38 8 8 *; =G M
O Y ) ) ) + + + * * *$ $ $
5 5 5 n ._ _ _*
$
$
$ + + +&
I I Is s s b b b"": ": ":H ; ; ; ; z & & &P? ? ? ? B6 6 68 ! ! !H H H3 3 3 [ r rH c |}d| cxk rt | k rn n|| dz
dk rdn| | dd| z
S )a Returns current column within a string, counting newlines as line separators.
The first column is number 1.
Note: the default parsing behavior is to expand tabs in the input string
before starting the parsing process. See
:class:`ParserElement.parseString` for more
information on parsing strings containing ```` s, and suggested
methods to maintain a consistent view of the parsed string, the parse
location, and line and column positions within the parsed string.
r r r
)r rfind)r strgr s r r` r` sb
AC #a&& Qs1uX%5%5113qRUAVAV;VVr c 6 | dd| dz S )a Returns current line number within a string, counting newlines as line separators.
The first line is number 1.
Note - the default parsing behavior is to expand tabs in the input string
before starting the parsing process. See :class:`ParserElement.parseString`
for more information on parsing strings containing ```` s, and
suggested methods to maintain a consistent view of the parsed string, the
parse location, and line and column positions within the parsed string.
r
r r )count)r r s r rq rq s ::dAs # #a ''r c | dd| }| d| }|dk r
||dz | S ||dz d S )zfReturns the line of text containing loc within a string, counting newlines as line separators.
r
r r N)r find)r r lastCRnextCRs r rn rn s\ ZZa
%
%F
YYtS
!
!F
{{FQJv%&&FQJKK r c t dt | z dz t | z dt || t || fz z d S )NzMatch z at loc z(%d,%d))printr rq r` )instringr exprs r _defaultStartDebugActionr sY 8eDkk !J .s ;i6RUW_K`K`befiksbtbtJu>u uwwwwwr c t dt | z dz t | z d S )NzMatched z -> )r r r rG )r startlocendlocr tokss r _defaultSuccessDebugActionr" s; *uT{{
"V
+c$++--.@.@
@AAAAAr c D t dt | z d S )NzException raised:)r r )r r r r s r _defaultExceptionDebugActionr$ s"
c
*+++++r c dS )zG'Do-nothing' debug action, to suppress debugging output during parsing.Nr )r s r rx rx s Dr r c
t v r fdS dg dgt d d dk r dd}ddnt j }t j d} |d d
}|d |d |z f
fd }d
} t dt d j }n # t $ r t }Y nw xY w||_ |S )Nc | S r r )r r r funcs r r z _trim_arity.. s ttAww r r Fr )r c z t dk rdnd}t j | | z dz
| }|d d gS )N)r r) r r limitr )system_version traceback
extract_stack)r. r
frame_summarys r r1 z"_trim_arity..extract_stack sJ )Y66RRBF % 36'E/A:M N N Nv VM!"1"%& &r c T t j | | }|d }|d d gS )Nr- r r )r0
extract_tb)tbr. framesr2 s r r4 z _trim_arity..extract_tb s2 )"E:::F "2JM!"1"%& &r r- r r c r | d d }dd< |S # t $ r d r t j d } |d d d d k s ~n'# t $ r Y nw xY w# ~w # t $ r Y w w xY wxY wd k rdxx dz
cc< Y w xY w)Nr r Tr r r- )rW r exc_info NameError) r r r5 r4
foundArityr( r. maxargspa_call_line_synths r r z _trim_arity..wrapper! s*
dDqO, $
1
a= !! \^^B / )z"A 6 6 6r :2A2 >BT T T ! U! " ( ! ! ! D!! " ( ! ! ! D! 8w&&!HHHMHHH H%
sh B69A?-A/.B6/
A<9B6;A<<B6?BBB
B
BB B B64B6zr __class__r[ ) singleArgBuiltinsr/ r0 r1 r4 getattrr r
r ) r( r< r1 LINE_DIFF this_liner func_namer4 r; r. r= s `` @@@@r r r sZ &&&&&
CEJ bqbV## ' ' ' '
' ' ' ' '
"/
)
I
A&&&r*I#A, ! y(@A 6 !I D* #D+ 6 6 ?A A II G Ns $B( (CCc e Zd ZdZdZdZed Zed Ze d Z
dNdZ d Z d Z
dNd
ZdNd ZdOd
Zd Zd Zd Zd Zd Zd ZdOdZd ZdPdZd Zd Z G d de Z e G d d e Z n G d d e Z i Z e! Z"d d gZ#dPd Z$eZ%ed! Z&dZ'edQd# Z(dNd$Z)e*dfd%Z+d& Z,e*fd'Z-e*dfd(Z.d) Z/d* Z0d+ Z1d, Z2d- Z3d. Z4d/ Z5d0 Z6d1 Z7d2 Z8d3 Z9d4 Z:d5 Z;d6 Zd9 Z?d: Z@d; ZAd< ZBd= ZCd> ZDdOd?ZEd@ ZFdA ZGdB ZHdC ZIdRdDZJdNdEZKdF ZLdG ZMdH ZNdI ZOdJ ZPdOdKZQ dSdMZRdS )TrJ z)Abstract base level parser element class.z
Fc | t _ dS )a
Overrides the default whitespace chars
Example::
# default whitespace chars are space, and newline
OneOrMore(Word(alphas)).parseString("abc def\nghi jkl") # -> ['abc', 'def', 'ghi', 'jkl']
# change to just treat newline as significant
ParserElement.setDefaultWhitespaceChars(" \t")
OneOrMore(Word(alphas)).parseString("abc def\nghi jkl") # -> ['abc', 'def']
N)rJ DEFAULT_WHITE_CHARScharss r setDefaultWhitespaceCharsz'ParserElement.setDefaultWhitespaceCharsL s -2
)))r c | t _ dS )ah
Set class to be used for inclusion of string literals into a parser.
Example::
# default literal class used is Literal
integer = Word(nums)
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
date_str.parseString("1999/12/31") # -> ['1999', '/', '12', '/', '31']
# change to Suppress
ParserElement.inlineLiteralsUsing(Suppress)
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
date_str.parseString("1999/12/31") # -> ['1999', '12', '31']
N)rJ _literalStringClassr s r inlineLiteralsUsingz!ParserElement.inlineLiteralsUsing\ s ( -0
)))r c 0 |j r|j }|j |S r )tb_next)r r5 s r _trim_tracebackz ParserElement._trim_tracebackr s$ j B j r c | t | _ d | _ d | _ d | _ || _ d| _ t t j | _
d| _ d| _ d| _
t | _ d| _ d| _ d| _ d| _ d| _ d| _ d | _ d| _ d| _ d S )NTFr NNN)rP parseAction
failActionstrRepr resultsName
saveAsListskipWhitespacer rJ rF
whiteCharscopyDefaultWhiteCharsmayReturnEmptykeepTabs ignoreExprsdebug streamlined
mayIndexErrorerrmsg modalResults debugActionsr callPreparse
callDuringTry)r savelists r r zParserElement.__init__x s 66 " " m ?@@%)" #
66
! . "r c t j | }| j dd |_ | j dd |_ | j rt j |_ |S )a/
Make a copy of this :class:`ParserElement`. Useful for defining
different parse actions for the same parsing pattern, using copies of
the original parse element.
Example::
integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
integerK = integer.copy().addParseAction(lambda toks: toks[0] * 1024) + Suppress("K")
integerM = integer.copy().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
prints::
[5120, 100, 655360, 268435456]
Equivalent form of ``expr.copy()`` is just ``expr()``::
integerM = integer().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
N)r rS r] rZ rJ rF rY )r cpys r r zParserElement.copy sQ , ioo *111- *111- % ? * >CN
r c r || _ d| j z | _ t j r| | S )a_
Define name for this expression, makes debugging and exception messages clearer.
Example::
Word(nums).parseString("ABC") # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
Word(nums).setName("integer").parseString("ABC") # -> Exception: Expected integer (at char 0), (line:1, col:1)
Expected )rF ra r! !enable_debug_on_named_expressionssetDebugr s r setNamezParserElement.setName s6 !DI- 5 MMOOO r c . | || S )aO
Define name for referencing matching tokens as a nested attribute
of the returned parse results.
NOTE: this returns a *copy* of the original :class:`ParserElement` object;
this is so that the client can define a basic element, such as an
integer, and reference it in multiple places with different names.
You can also set results names using the abbreviated syntax,
``expr("name")`` in place of ``expr.setResultsName("name")``
- see :class:`__call__`.
Example::
date_str = (integer.setResultsName("year") + '/'
+ integer.setResultsName("month") + '/'
+ integer.setResultsName("day"))
# equivalent form:
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
)_setResultsName)r rF listAllMatchess r setResultsNamez ParserElement.setResultsName s * ##D.999r c | }| d r |d d }d}||_ | |_ |S )N*r T)r endswithrV rb )r rF rp newselfs r ro z ParserElement._setResultsName sM ))++ == "9D !N "#1 1 r Tc |r | j dfd }|_ || _ n&t | j d r| j j | _ | S )zMethod to invoke the Python pdb debugger when this element is
about to be parsed. Set ``breakFlag`` to True to enable, False to
disable.
Tc P dd l }| | ||| S r< )pdb set_trace)r r doActions callPreParserx _parseMethods r breakerz'ParserElement.setBreak..breaker s/
#|Hc9lKKKr _originalParseMethodTT)_parser~ r )r breakFlagr} r| s @r setBreakzParserElement.setBreak sq
? ;L
L
L
L
L
L
L
,8G (!DKKt{$:;;
? "k > r c , t | dgk rg | _ nwt d |D st d t t t
t | | _ | dd | _ | S )a
Define one or more actions to perform when successfully matching parse element definition.
Parse action fn is a callable method with 0-3 arguments, called as ``fn(s, loc, toks)`` ,
``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where:
- s = the original string being parsed (see note below)
- loc = the location of the matching substring
- toks = a list of the matched tokens, packaged as a :class:`ParseResults` object
If the functions in fns modify the tokens, they can return them as the return
value from fn, and the modified list of tokens will replace the original.
Otherwise, fn does not need to return any value.
If None is passed as the parse action, all previously added parse actions for this
expression are cleared.
Optional keyword arguments:
- callDuringTry = (default= ``False``) indicate if parse action should be run during lookaheads and alternate testing
Note: the default parsing behavior is to expand tabs in the input string
before starting the parsing process. See :class:`parseString for more
information on parsing strings containing ```` s, and suggested
methods to maintain a consistent view of the parsed string, the parse
location, and line and column positions within the parsed string.
Example::
integer = Word(nums)
date_str = integer + '/' + integer + '/' + integer
date_str.parseString("1999/12/31") # -> ['1999', '/', '12', '/', '31']
# use parse action to convert to ints at parse time
integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
date_str = integer + '/' + integer + '/' + integer
# note that integer fields are now ints, not strings
date_str.parseString("1999/12/31") # -> [1999, '/', 12, '/', 31]
Nc 3 4 K | ]}t | V d S r )callable)r r s r r z/ParserElement.setParseAction.. s( 22x||222222r z parse actions must be callablere F)rP rS allrW mapr r re r fnsr s r r z ParserElement.setParseAction s P 99 !D 22c22222
B @AAA #C T#YY$?$? @ @D !'OU!C!CD r c
| xj t t t t | z
c_ | j p| dd | _ | S )z
Add one or more parse actions to expression's list of parse actions. See :class:`setParseAction`.
See examples in :class:`copy`.
re F)rS rP r r re r r s r addParseActionz ParserElement.addParseAction sS
D[$s))!= 2000, message="Only support years 2000 and later")
date_str = year_int + '/' + integer + '/' + integer
result = date_str.parseString("1999/12/31") # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
r r F)r r re )rS r r r re )r r r r s r addConditionzParserElement.addCondition) s $ ^ ^B # #$:2vzzR[G\G\AGGUZA[A[%] %] %]
^
^
^
^ " / U6::ou3U3U r c || _ | S )a Define action to perform if parsing fails at this expression.
Fail acton fn is a callable function that takes the arguments
``fn(s, loc, expr, err)`` where:
- s = string being parsed
- loc = location where expression match was attempted and failed
- expr = the parse expression that failed
- err = the exception thrown
The function returns no value. It may throw :class:`ParseFatalException`
if it is desired to stop parsing immediately.)rT r r s r
setFailActionzParserElement.setFailActionB s r c d}|r;d}| j D ]/} | || \ }}d} # t $ r Y ,w xY w|;|S NTF)r] r rE )r r r
exprsFoundedummys r _skipIgnorablesz ParserElement._skipIgnorablesO s
J%
*%&XXh%<%<
U%)
* & D
s .
;;c | j r| || }| j r;| j }t | }||k r || |v r|dz
}||k r
|| |v |S Nr )r] r rX rY r )r r r wtinstrlens r preParsezParserElement.preParse\ s 6&&x55C B8}}H..Xc]b%8%8q ..Xc]b%8%8
r c
|g fS r r r r r rz s r r
zParserElement.parseImplh s Bwr c |S r r r r r tokenlists r postParsezParserElement.postParsek s r c
L d\ }}}| j }|s| j r%| j | r | j | ||| |r | j r| || } n|} | }
| j s| t
| k rN | || | \ }} nL# t $ r% t |t
| | j
| w xY w| || | \ }} n# t $ rK} | j | r | j | ||
| | | j r| ||
| | d } ~ ww xY w|r | j r| || } n|} | }
| j s| t
| k rN | || | \ }} nL# t $ r% t |t
| | j
| w xY w| || | \ }} | ||| } t | | j | j | j }
| j rU|s| j rK|r | j D ]} |||
|
} n*# t $ r }t d }||_ |d }~ww xY w| B| |
ur>t | | j | j ot) | t t* f | j }
n# t $ r,} | j | r | j | ||
| | d } ~ ww xY w| j D ]} |||
|
} n*# t $ r }t d }||_ |d }~ww xY w| B| |
ur>t | | j | j ot) | t t* f | j }
|r'| j | r | j | ||
|| |
||
fS )N)r r r )rG rH z exception raised in parse action)r^ rT rc rd r r` r r
rX rE ra r
r rH rV rW rb rS re __cause__r rP )r r r rz r{ TRYMATCHFAIL debuggingpreloc tokensStarttokenserr retTokensr parse_action_excr s r r zParserElement._parseNoCacheo s "UDZ $ J $ J %
<&!#&xd;;;
!D$5 ! !]]8S 9 9FF F $ % N3x==)@)@Y&*nnXvy&Q&Q VV% Y Y Y ,Xs8}}dkSW X XXY #'..69"M"MKC
$T* N+D%d+Hk4MMM? FOOHk4EEE
1
x55 K!
JVs8}}%<%<U"&..69"M"MKC! U U U(3x==$+tTTTU #nnXvy I I V #v66 )9$/Y]Yjkkk " K " Kd.@ " K !
K " . O O&%'R+y%I%IFF ) & & &"01S"T"TC,C% =B C% /C C% %
D:/AD55D:<F /G1 J9 ;
I J9
I0I++I00AJ9 9
K/'K**K/<
L
L1L,,L1c | ||d d S # t $ r t ||| j | w xY w)NFrz r )r rG rE ra r r r s r tryParsezParserElement.tryParse sZ C;;x;>>qA A" C C C 3 TBB B Cs "Ac d | || dS # t t f$ r Y dS w xY wr )r rE rX r s r canParseNextzParserElement.canParseNext sK MM(C ( ( ( 4
+ 55 s //c e Zd Zd ZdS ) ParserElement._UnboundedCachec 2 i t x| _ fd}fd}fd}fd}t j || | _ t j || | _ t j || | _ t j || | _ d S )Nc 0 | S r r r r cache not_in_caches r r z3ParserElement._UnboundedCache.__init__..get s yyl333r c ||< d S r r )r r rm r s r r z3ParserElement._UnboundedCache.__init__..set s "c
r c 0 d S r r r r s r r z5ParserElement._UnboundedCache.__init__..clear s
r c " t S r r r s r cache_lenz9ParserElement._UnboundedCache.__init__..cache_len s 5zz!r )rB r types
MethodTyper r r rs )r r r r r r r s @@r r z&ParserElement._UnboundedCache.__init__ s E/5xx 7D
4
4
4
4
4
4
#
#
#
#
#
"
"
"
"
" 'T22DH 'T22DH )%66DJ +It<.get 99S,777r c ||< t k r< d n# t $ r Y nw xY wt k :d S d S r )r popitemrV )r r rm r sizes r r z.ParserElement._FifoCache.__init__..set sv !&E#J e**t++! !MM% 0 0 0 0 ' ! ! ! D! e**t++++++s 1
>>c 0 d S r r r s r r z0ParserElement._FifoCache.__init__..clear s KKMMMMMr c " t S r r r s r r z4ParserElement._FifoCache.__init__..cache_len u::%r ) rB r _OrderedDictr r r r r rs )r r r r r r r r s ` @@r r z!ParserElement._FifoCache.__init__ s 3988;!L$8 8 8 8 8 8! ! ! ! ! !" " " " "& & & & & !+C66 +C66 " -eT : :
$ / 4 @ @ r Nr r r r
_FifoCacher (
A
A
A
A
Ar r c e Zd Zd ZdS )r c f t x| _ i t j g fd}fd}fd}fd}t j || | _ t j || | _ t j || | _ t j || | _ d S )Nc 0 | S r r r s r r z.ParserElement._FifoCache.__init__..get r r c ||< t k r; d t k ; | d S r )r r popleftr )r r rm r key_fifor s r r z.ParserElement._FifoCache.__init__..set sh !&E#J h--$.. ("2"2"4"4d;;; h--$.. OOC(((((r c X d S r r )r r r s r r z0ParserElement._FifoCache.__init__..clear s& KKMMM NN$$$$$r c " t S r r r s r r z4ParserElement._FifoCache.__init__..cache_len r r )
rB r collectionsdequer r r r r rs ) r r r r r r r r r s ` @@@r r z!ParserElement._FifoCache.__init__ s 3988;!L&,R668 8 8 8 8 8) ) ) ) ) ) ) % % % % % %& & & & & !+C66 +C66 " -eT : :
$ / 4 @ @ r Nr r r r r zParserElement._FifoCache r r r c d\ }}| ||||f}t j 5 t j }| | } | |j u rt j |xx dz
cc< | |||| } | || d | d f | cd d d S # t $ r)}
| | |
j
|
j d }
~
ww xY wt j |xx dz
cc< t | t r| | d | d fcd d d S # 1 swxY w Y d S )Nr r r )rJ packrat_cache_lock
packrat_cacher r packrat_cache_statsr r r rC r> r r r
) r r r rz r{ HITMISSlookupr rm r s r _parseCachezParserElement._parseCache+ s T#|Y?
- 1 1!/EIIf%%E*** 1$7771<777! . .xi V VE IIfuQxq &ABBB 1 1 1 1 1 1 1 1 * IIflblBG&<=== 1#666!;666 eY// K Qxq 0% 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1s7 AE B;77E;
C.$C))C..AEEEc t j dgt t j z t j d d < d S r< )rJ r r r r r r r
resetCachezParserElement.resetCacheD s@ #))+++01sS 9Z5[5[/[
)!!!,,,r c t j sndt _ | $t t _ n$t | t _ t j t _ dS dS )a Enables "packrat" parsing, which adds memoizing to the parsing logic.
Repeated parse attempts at the same string location (which happens
often in many complex grammars) can immediately return a cached value,
instead of re-executing parsing/validating code. Memoizing is done of
both valid results and parsing exceptions.
Parameters:
- cache_size_limit - (default= ``128``) - if an integer value is provided
will limit the size of the packrat cache; if None is passed, then
the cache size will be unbounded; if 0 is passed, the cache will
be effectively disabled.
This speedup may break existing programs that use parse actions that
have side-effects. For this reason, packrat parsing is disabled when
you first import pyparsing. To activate the packrat feature, your
program must call the class method :class:`ParserElement.enablePackrat`.
For best results, call ``enablePackrat()`` immediately after
importing pyparsing.
Example::
from pip._vendor import pyparsing
pyparsing.ParserElement.enablePackrat()
TN)rJ _packratEnabledr r r r r )cache_size_limits r
enablePackratzParserElement.enablePackratJ sf 6 , =,0M ) '.;.K.K.M.M
++.;.F.FGW.X.X
+#0# ['aaaaa']
Word('a').parseString('aaaaabaaa', parseAll=True) # -> Exception: Expected end of text
r r N)rJ r r_
streamliner] r\
expandtabsr r r2 rO rC verbose_stacktracer@ rP r )r r parseAllr r r ser s r parseStringzParserElement.parseStringm s3 B """ OO ! A
LLNNNN} - **,,H ++h22KC
)mmHc22WWy{{* (C((( M " /
366B(,(<( OO ! A
LLNNNN} 4 X1133Hx==]
+ """ //g
&:&:) 'Z# 6 6F&-ghU&S&S&SOGV }} 1 $fg 5555" *&0j3&?&?G &}}&- #q")CC $qj & % % % 1*CCC% //g
&:&:&:&://&:&://( " /
366B(,(<(. s '''Q'1'''r r r )r\ r r r rH rG rP r r r _flattenrC rJ r r@ rP r )r r r lastEr r r r s r r z ParserElement.transformString sh (
??844
1a
8E!G,--- &!!\22 &qxxzz)#At,, &q
1
JJx' ( ( (''c'''C773uhsmm4455 5! /
366B(,(<(.7 s X X Xwq!Q X X Xr r N)rH r rC rJ r r@ rP r )r r r r s r searchStringzParserElement.searchString! s * X X$//(J2W2W X X XYY Y! /
366B(,(<(", greet.parseString(hello))
prints::
Hello, World! -> ['Hello', ',', 'World', '!']
``...`` may be used as a parse expression as a short form of :class:`SkipTo`.
Literal('start') + ... + Literal('end')
is equivalent to:
Literal('start') + SkipTo('end')("_skipped*") + Literal('end')
Note that the skipped text is returned with '_skipped' as a results name,
and to support having multiple skips in the same parser, the value returned is
a list of all skipped text.
4Cannot combine element of type %s with ParserElementr
stacklevelN) Ellipsis _PendingSkipr rU rK rJ warningswarnr
SyntaxWarningr+ r s r r zParserElement.__add__Z s 6 H %% % eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
74D%=!!!r c . |t u r t | d | z S t |t r| | }t |t
s.t
j dt | z t d dS || z S )z`
Implementation of + operator when left operand is not a :class:`ParserElement`
_skipped*r r r N)
r rN r rU rK rJ r r r r r s r r zParserElement.__radd__ s H 6$<< ,,t3 3 eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
74t|r c t |t r| | }t |t s.t j dt
| z t d dS | t z |z S )zT
Implementation of - operator, returns :class:`And` with error stop
r r r N)
r rU rK rJ r r r r r+
_ErrorStopr s r __sub__zParserElement.__sub__ s eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
74cnn&&&..r c t |t r| | }t |t s.t j dt
| z t d dS || z
S )z`
Implementation of - operator when left operand is not a :class:`ParserElement`
r r r Nr rU rK rJ r r r r r s r __rsub__zParserElement.__rsub__ z eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
74t|r c |t u rd}nAt |t r,|dd t fk rd|dd z dz dd }t |t r|d}}nWt |t r$t d |D }|d z dd }|d
d|d f}t |d t rY|d Q|d dk rt S |d dk rt S |d z t z S t |d t r&t |d t r |\ }}||z }nTt
d
t |d t |d t
d t | |dk rt d |dk rt d
||cxk rdk rn nt d |rI fd|r5|dk r | z }nHt g|z | z }n( | }n |dk r }nt g|z }|S )a
Implementation of * operator, allows use of ``expr * 3`` in place of
``expr + expr + expr``. Expressions may also me multiplied by a 2-integer
tuple, similar to ``{min, max}`` multipliers in regular expressions. Tuples
may also include ``None`` as in:
- ``expr*(n, None)`` or ``expr*(n, )`` is equivalent
to ``expr*n + ZeroOrMore(expr)``
(read as "at least n instances of ``expr``")
- ``expr*(None, n)`` is equivalent to ``expr*(0, n)``
(read as "0 to n instances of ``expr``")
- ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)``
- ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)``
Note that ``expr*(None, n)`` does not raise an exception if
more than n exprs exist in the input stream; that is,
``expr*(None, n)`` does not enforce a maximum number of expr
occurrences. If this behavior is desired, then write
``expr*(None, n) + ~expr``
)r NNr r[ r r r c 3 0 K | ]}|t ur|nd V d S r )r r s r r z(ParserElement.__mul__.. s0 JJqq 0 0!!dJJJJJJr NNz8cannot multiply 'ParserElement' and ('%s', '%s') objectsz0cannot multiply 'ParserElement' and '%s' objectsz/cannot multiply ParserElement by negative valuez@second tuple value must be greater or equal to first tuple valuez,cannot multiply ParserElement by 0 or (0, 0)c j | dk r t | dz
z S t S r )rA )nmakeOptionalListr s r r$ z/ParserElement.__mul__..makeOptionalList s; q55#D+;+;AE+B+B$BCCC#D>>)r )
r r tupler rX r? rW r
ValueErrorr+ )r r minElements optElementsr r$ s ` @r __mul__zParserElement.__mul__ s ( H EE
u
%
% 6%){*B*BU122Y&0"1"5E eS ! ! ]',aKK
u
%
% ]JJEJJJJJE\)2A2.EQx E!H
%(C((
|U1X-=8q==%d+++8q==$T??* %(?Z-=-===E!Hc**
|z%(C/H/H
|+0( [{* Z\`afghai\j\jlpqvwxqylzlz{{{ NPTUZP[P[\\ \ ?? NOO O ?? _`` ` + * * * * * * * * * KLL L 0
*
*
*
*
*
*
4 !## !1!1+!>!>>CC tf{ 2336F6F{6S6SSCC&&{33a 4&;.//
r c , | | S r )r) r s r __rmul__zParserElement.__rmul__ s ||E"""r c 2 |t u rt | d S t |t r| | }t |t
s.t
j dt | z t d dS t | |g S )zL
Implementation of | operator - returns :class:`MatchFirst`
T) must_skipr r r N) r r r rU rK rJ r r r r r< r s r __or__zParserElement.__or__ s H 555 5 eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
744-(((r c t |t r| | }t |t s.t j dt
| z t d dS || z S )z`
Implementation of | operator when left operand is not a :class:`ParserElement`
r r r Nr r s r __ror__zParserElement.__ror__ r r c t |t r| | }t |t s.t j dt
| z t d dS t | |g S )zD
Implementation of ^ operator - returns :class:`Or`
r r r N) r rU rK rJ r r r r rB r s r __xor__zParserElement.__xor__ s eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
744- r c t |t r| | }t |t s.t j dt
| z t d dS || z S )z`
Implementation of ^ operator when left operand is not a :class:`ParserElement`
r r r Nr r s r __rxor__zParserElement.__rxor__ r r c t |t r| | }t |t s.t j dt
| z t d dS t | |g S )zF
Implementation of & operator - returns :class:`Each`
r r r N) r rU rK rJ r r r r r1 r s r __and__zParserElement.__and__' s eZ ( ( 4,,U33E% // MPSWX]S^S^^'A
7
7
7
74T5M"""r c t |t r| | }t |t s.t j dt
| z t d dS || z S )z`
Implementation of & operator when left operand is not a :class:`ParserElement`
r r r Nr r s r __rand__zParserElement.__rand__3 r r c t | S )zH
Implementation of ~ operator - returns :class:`NotAny`
)r> r s r
__invert__zParserElement.__invert__? s d||r c : t d| j j z )Nz%r object is not iterable)rW r> r r s r rz zParserElement.__iter__E s 3dn6MMNNNr c
t |t r|f}t | n# t $ r ||f}Y nw xY wt | dk ret j d |dd t | dk r"d t | nd | t |dd z }|S )a
use ``[]`` indexing notation as a short form for expression repetition:
- ``expr[n]`` is equivalent to ``expr*n``
- ``expr[m, n]`` is equivalent to ``expr*(m, n)``
- ``expr[n, ...]`` or ``expr[n,]`` is equivalent
to ``expr*n + ZeroOrMore(expr)``
(read as "at least n instances of ``expr``")
- ``expr[..., n]`` is equivalent to ``expr*(0, n)``
(read as "0 to n instances of ``expr``")
- ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)``
- ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)``
``None`` may be used in place of ``...``.
Note that ``expr[..., n]`` and ``expr[m, n]``do not raise an exception
if more than ``n`` ``expr``s exist in the input stream. If this behavior is
desired, then write ``expr[..., n] + ~expr``.
r z.only 1 or 2 index arguments supported ({0}{1})Nr) z ... [{0}]r ) r r ry rW r r r r r% )r r r s r r: zParserElement.__getitem__J s ( #s##
f IIII *CCC s88a<< MJQQRUVXWXVXRYSVWZS[S[^_S_S_ Q\PbPbcfgjckckPlPlPlegi i
j
j
j
U3rr7^^#
s '* ;;c X || | S | S )a
Shortcut for :class:`setResultsName`, with ``listAllMatches=False``.
If ``name`` is given with a trailing ``'*'`` character, then ``listAllMatches`` will be
passed as ``True``.
If ``name` is omitted, same as calling :class:`copy`.
Example::
# these are equivalent
userdata = Word(alphas).setResultsName("name") + Word(nums + "-").setResultsName("socsecno")
userdata = Word(alphas)("name") + Word(nums + "-")("socsecno")
)ro r r s r __call__zParserElement.__call__n s, ''-- -99;; r c t | S )z
Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from
cluttering up returned output.
)rQ r s r suppresszParserElement.suppress s
~~ r c d| _ | S )a
Disables the skipping of whitespace before matching the characters in the
:class:`ParserElement`'s defined pattern. This is normally only used internally by
the pyparsing module, but may be needed in some whitespace-sensitive grammars.
FrX r s r leaveWhitespacez ParserElement.leaveWhitespace s $ r c 0 d| _ || _ d| _ | S )z8
Overrides the default whitespace chars
TF)rX rY rZ )r rH s r setWhitespaceCharsz ParserElement.setWhitespaceChars s # %*" r c d| _ | S )z
Overrides default behavior to expand ````s to spaces before parsing the input string.
Must be called before ``parseString`` when the input grammar contains elements that
match ```` characters.
T)r\ r s r
parseWithTabszParserElement.parseWithTabs s
r c 2 t |t rt | }t |t r$|| j vr| j | n9| j t | | S )a
Define expression to be ignored (e.g., comments) while doing pattern
matching; may be called repeatedly, to define multiple comment or other
ignorable patterns.
Example::
patt = OneOrMore(Word(alphas))
patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
patt.ignore(cStyleComment)
patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
)r rU rQ r] r r r s r ignorezParserElement.ignore s eZ ( ( $ UOOE eX & & <D ,,, ''... # #HUZZ\\$:$: ; ; ; r c R |pt |pt |pt f| _ d| _ | S )zT
Enable display of debugging messages while doing pattern matching.
T)r r" r$ rc r^ )r startAction
successActionexceptionActions r setDebugActionsz ParserElement.setDebugActions s8 ) D,D * H.H , L0L N
r c f |r'| t t t nd| _ | S )a
Enable display of debugging messages while doing pattern matching.
Set ``flag`` to True to enable, False to disable.
Example::
wd = Word(alphas).setName("alphaword")
integer = Word(nums).setName("numword")
term = wd | integer
# turn on debugging for wd
wd.setDebug()
OneOrMore(term).parseString("abc 123 xyz 890")
prints::
Match alphaword at loc 0(1,1)
Matched alphaword -> ['abc']
Match alphaword at loc 3(1,4)
Exception raised:Expected alphaword (at char 4), (line:1, col:5)
Match alphaword at loc 7(1,8)
Matched alphaword -> ['xyz']
Match alphaword at loc 11(1,12)
Exception raised:Expected alphaword (at char 12), (line:1, col:13)
Match alphaword at loc 15(1,16)
Exception raised:Expected alphaword (at char 15), (line:1, col:16)
The output shown is that produced by the default debug actions - custom debug actions can be
specified using :class:`setDebugActions`. Prior to attempting
to match the ``wd`` expression, the debugging message ``"Match at loc (,)"``
is shown. Then if the parse succeeds, a ``"Matched"`` message is shown, or an ``"Exception raised"``
message is shown. Also note the use of :class:`setName` to assign a human-readable name to the expression,
which makes debugging and exception messages easier to understand - for instance, the default
name created for the :class:`Word` expression without calling ``setName`` is ``"W:(ABCD...)"``.
F)rN r r" r$ r^ )r flags r rl zParserElement.setDebug s7 J !9;UWs t t t t DJ r c | j S r r r s r r zParserElement.__str__ s
yr c t | S r r r s r r zParserElement.__repr__ r r c " d| _ d | _ | S r )r_ rU r s r r zParserElement.streamline s r c d S r r r. s r checkRecursionz ParserElement.checkRecursion s r c 0 | g dS )zj
Check defined expressions for valid structure, check for infinite recursive definitions.
N)rU )r
validateTraces r validatezParserElement.validate s
B r c | }nL# t $ r? t |d 5 }| }ddd n # 1 swxY w Y Y nw xY w | || S # t $ rD}t
j r t |dd | |j |_ |d}~ww xY w)z
Execute the parse expression on the given file or filename.
If a filename is specified (instead of a file object),
the entire file is opened, read, and closed before parsing.
rNr )
readr openr rC rJ r r@ rP r )r file_or_filenamer
file_contentsfr s r parseFilezParserElement.parseFile
s! ) , 1 1 3 3MM ) ) )&,,
) !
)
)
)
)
)
)
)
)
)
)
)
)
)
)
) ) ##M8<< <! /
366B(,(<(>>
#9#@#@ASUYZ[U\U\Uegh#i#ijjjjjjjjk JJv{{{ 9 9::::= &
%/4G%H%HP b199JJtBFA///JJsc"&!nnq&8 9C ?% GHHHHJJsRV|c 1E 9:::
8c"gg-...!2l
-C8999!2l
,
' #JJrNNNtyy~~&&& q&k * * * *
""s? ?K BH##
J"-A*J J"
O)CN''
O)4+O$$O)FTr )r r )Trq TTFNN)Sr r r r rF r r& rI rM r rP r r rm rq ro r r r r r r r r
r r r r rB r r r r r
r r r r r r r r _MAX_INTr r r r r r r r r) r+ r. r0 r2 r4 r6 r8 r: rz r: r> r@ rC rE rG rI rN rl r r r rU rX r` rc re ri rk rm r r r r r rJ rJ G s 33#
2
2 \
2 0 0 \0* [
# # # #. :
: : : :. &/ / /b 2
U U U U nC C C = = = = =& = = =, A A A A A A A A A: A A A A A A A A: M a&1 1 1 1. F\ \ \\ O = = = \ =D8 8 8 8t /7 H H H HT. . .` 19 @ (05 2$" $" $"L
/
/
/
H H HT# # #
)
)
)
!
!
!
#
#
#
O O O
" " "H ( 0 ) ) ) )V
, # # # # # # ( 69QU`# `# `# `# `# `#r rJ c 2 e Zd Zd fd Zd Zd Zd Z xZS )r Fc t t | t |t z dd | _ | j | _ || _ || _ d S )Nr2 ...)
superr r r r2 r rU rF anchorr- )r r r- r> s r r z_PendingSkip.__init__
sa
lD!!**,,,4%''>**227EBB L "r c t | d d } j rNd } fd} j | | z | | z |z S j |z |z S )Nr r c | j r | j dgk r| d= | dd d S d S )Nr r _skipped)r rG r r s r r- z'_PendingSkip.__add__..must_skip
sP z ,QZ%6%6%8%8RD%@%@!EE*d+++++ &A%@r c | j dd dgk r4| d }dt j z dz | d< d S d S )Nr r r z missing .show_skip
sa :$$&&rss+t33 eeJ / /G$/$t{2C2C$Cc$IAjMMM 43r )rN rm r- r r )r r skipperr- r s ` r r z_PendingSkip.__add__
s .&--''..{;; >
C
,
,
,
J
J
J
J
J K''))":":9"E"EE gii..y99:=BC
C {W$u,,r c | j S r )rU r s r r z_PendingSkip.__repr__ s
|r c t d )NzBuse of `...` expression without following SkipTo target expression)r
r r s r r
z_PendingSkip.parseImpl s \]]]r r )r r r r r r r
__classcell__r> s @r r r
sq # # # # # #- - - ^ ^ ^ ^ ^ ^ ^r r c " e Zd ZdZ fdZ xZS )rR zYAbstract :class:`ParserElement` subclass, for defining atomic
matching patterns.
c Z t t | d d S NFrf )r rR r r r> s r r zToken.__init__ s*
eT##U#33333r r r r r r r r s @r rR rR sB 4 4 4 4 4 4 4 4 4r rR c " e Zd ZdZ fdZ xZS )r2 z'An empty token, will always match.
c t t | d| _ d| _ d| _ d S )Nr2 TF)r r2 r rF r[ r` r s r r zEmpty.__init__ s<
eT##%%% " "r r r s @r r2 r2 sB # # # # # # # # #r r2 c * e Zd ZdZ fdZddZ xZS )r= z#A token that will never match.
c t t | d| _ d| _ d| _ d| _ d S )Nr= TFzUnmatchable token)r r= r rF r[ r` ra r s r r zNoMatch.__init__ sA
gt %%''' " ") r Tc 0 t ||| j | r )rE ra r s r r
zNoMatch.parseImpl$ s XsDK>>>r r r r r r r r
r r s @r r= r= sV * * * * *? ? ? ? ? ? ? ?r r= c * e Zd ZdZ fdZddZ xZS )r: a Token to exactly match a specified string.
Example::
Literal('blah').parseString('blah') # -> ['blah']
Literal('blah').parseString('blahfooblah') # -> ['blah']
Literal('blah').parseString('bla') # -> Exception: Expected "blah"
For case-insensitive matching, use :class:`CaselessLiteral`.
For keyword matching (force word break before and after the matched string),
use :class:`Keyword` or :class:`CaselessKeyword`.
c t t | || _ t | | _ |d | _ n8# t $ r+ t j dt d t | _ Y nw xY wdt | j z | _ d| j z | _ d| _ d| _ | j dk r$t% | t u rt& | _ d S d S d S ) Nr z2null string passed to Literal; use Empty() insteadr r "%s"rj Fr )r r: r matchr matchLenfirstMatchCharrX r r r r2 r> r rF ra r[ r` r _SingleCharLiteralr matchStringr> s r r zLiteral.__init__6 s
gt %%'''
K((
#"-a.D # # # MN )a
9
9
9
9 "DNNN # U4: . .. !DI- # " =A $t**"7"7 /DNNN "7"7s
A 2BBTc || | j k r,| | j | r|| j z | j fS t ||| j | r )r r r r rE ra r s r r
zLiteral.parseImplJ sV C=D / / /H4G4G
TW4X4X / &
2 2 XsDK>>>r r r r s @r r: r: ( sV 0 0 0 0 0(? ? ? ? ? ? ? ?r r: c e Zd ZddZdS )r Tc j || | j k r |dz | j fS t ||| j | r )r r rE ra r s r r
z _SingleCharLiteral.parseImplP s; C=D / / /7DJ& & XsDK>>>r Nr r r r r
r r r r r O s( ? ? ? ? ? ?r r c V e Zd ZdZedz Zd
fd Zd dZ fdZe d Z
xZ S ) r7 a Token to exactly match a specified string as a keyword, that is,
it must be immediately followed by a non-keyword character. Compare
with :class:`Literal`:
- ``Literal("if")`` will match the leading ``'if'`` in
``'ifAndOnlyIf'``.
- ``Keyword("if")`` will not; it will only match the leading
``'if'`` in ``'if x=1'``, or ``'if(y==2)'``
Accepts two optional constructor arguments in addition to the
keyword string:
- ``identChars`` is a string of characters that would be valid
identifier characters, defaulting to all alphanumerics + "_" and
"$"
- ``caseless`` allows case-insensitive matching, default is ``False``.
Example::
Keyword("start").parseString("start") # -> ['start']
Keyword("start").parseString("starting") # -> Exception
For case-insensitive matching, use :class:`CaselessKeyword`.
_$NFc
t t | | t j }|| _ t | | _ |d | _ n,# t $ r t j
dt d Y nw xY wd| j z | _ d| j z | _
d| _ d| _ || _ |r-| | _ | }t' | | _ d S )Nr z2null string passed to Keyword; use Empty() insteadr r r rj F)r r7 r DEFAULT_KEYWORD_CHARSr r r r rX r r r rF ra r[ r` caselessupper
caselessmatchr
identChars)r r r r r> s r r zKeyword.__init__s s
gt %%''' 6J
K((
7"-a.D 7 7 7 MN'A
7
7
7
7
7
7 7 TZ' !DI- # "
,!,!2!2!4!4D #))++J j//s
A! !&B
B
Tc | j r|||| j z | j k r|t | | j z
k s)||| j z | j vr;|dk s$||dz
| j vr|| j z | j fS n|| | j k r| j dk s| | j | r[|t | | j z
k s||| j z | j vr)|dk s||dz
| j vr|| j z | j fS t ||| j
| rd ) r r r r r r r r r rE ra r s r r
zKeyword.parseImpl se = ;#cDM 11288::d>PPP H
=== $S4=%8 9 ? ? A A X X $S1W - 3 3 5 5T_ L LT]*DJ66 } 333]a''8+>+>tz3+O+O' CMMDM$A A A (t})< =T_ T T AXX#'):$/)Q)Q .
:: XsDK>>>r c x t t | }t j |_ |S r )r r7 r r r )r r r> s r r z Keyword.copy s- '4 % % ' ' 4 r c | t _ dS )z,Overrides the default Keyword chars
N)r7 r rG s r setDefaultKeywordCharsz Keyword.setDefaultKeywordChars s ).%%%r r r ) r r r r rZ r r r
r r& r r r s @r r7 r7 X s 0 & ,* * * * * **? ? ? ?&
. . \. . . . .r r7 c * e Zd ZdZ fdZddZ xZS )r- af Token to match a specified string, ignoring case of letters.
Note: the matched results will always be in the case of the given
match string, NOT the case of the input text.
Example::
OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
(Contrast with example for :class:`CaselessKeyword`.)
c t t | | || _ d| j z | _ d| j z | _ d S )Nz'%s'rj )r r- r r returnStringrF ra r s r r zCaselessLiteral.__init__ sV
ot$$--k.?.?.A.ABBB 'T .. !DI- r Tc |||| j z | j k r|| j z | j fS t ||| j | r )r r r r rE ra r s r r
zCaselessLiteral.parseImpl sW Cdm++ , 2 2 4 4
B B &(99 9 XsDK>>>r r r r s @r r- r- sV . . . . .? ? ? ? ? ? ? ?r r- c $ e Zd ZdZd fd Z xZS )r, z
Caseless version of :class:`Keyword`.
Example::
OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
(Contrast with example for :class:`CaselessLiteral`.)
Nc ^ t t | ||d d S )NTr )r r, r )r r r r> s r r zCaselessKeyword.__init__ s/
ot$$--k:PT-UUUUUr r r r s @r r, r, sQ V V V V V V V V V Vr r, c , e Zd ZdZd fd ZddZ xZS )r a A variation on :class:`Literal` which matches "close" matches,
that is, strings with at most 'n' mismatching characters.
:class:`CloseMatch` takes parameters:
- ``match_string`` - string to be matched
- ``maxMismatches`` - (``default=1``) maximum number of
mismatches allowed to count as a match
The results from a successful parse will contain the matched text
from the input string and the following named results:
- ``mismatches`` - a list of the positions within the
match_string where mismatches were found
- ``original`` - the original match_string used to compare
against the input string
If ``mismatches`` is an empty list, then the match was an exact
match.
Example::
patt = CloseMatch("ATCATCGAATGGA")
patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
# exact match
patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
# close match allowing up to 2 mismatches
patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
r c t t | || _ || _ || _ d| j | j fz | _ d| _ d| _ d S )Nz&Expected %r (with up to %d mismatches)F) r r r rF match_string
maxMismatchesra r` r[ )r r r r> s r r zCloseMatch.__init__ sd
j$ ((*** ( *>$BSUYUgAhh " #r Tc |}t | }|t | j z }||k r| j }d}g } | j }
t t ||| | D ]:\ }} | \ } }
| |
k r*| | t | |
k r n,;|dz }t
||| g }||d< | |d< ||fS t ||| j | )Nr r original
mismatches) r r r r r r rH rE ra )r r r rz startr maxlocr match_stringlocr r s_msrcmatresultss r r
zCloseMatch.parseImpl s x==T ./// X ,L OJ .M(1#hs6z6JL2Y2Y(Z(Z
$
$$ S#:: %%o666: 66 %)&s(;'<==&2
#(2 %G|# XsDK>>>r )r r r r s @r r r s\ @$ $ $ $ $ $? ? ? ? ? ? ? ?r r c 6 e Zd ZdZd
fd Zd dZ fd Z xZS ) rU aX Token for matching words composed of allowed character sets.
Defined with string containing all allowed initial characters, an
optional string containing allowed body characters (if omitted,
defaults to the initial character set), and an optional minimum,
maximum, and/or exact length. The default value for ``min`` is
1 (a minimum value < 1 is not valid); the default values for
``max`` and ``exact`` are 0, meaning no maximum or exact
length restriction. An optional ``excludeChars`` parameter can
list characters that might be found in the input ``bodyChars``
string; useful to define a word of all printables except for one or
two characters, for instance.
:class:`srange` is useful for defining custom character set strings
for defining ``Word`` expressions, using range notation from
regular expression character sets.
A common mistake is to use :class:`Word` to match a specific literal
string, as in ``Word("Address")``. Remember that :class:`Word`
uses the string argument to define *sets* of matchable characters.
This expression would match "Add", "AAA", "dAred", or any other word
made up of the characters 'A', 'd', 'r', 'e', and 's'. To match an
exact literal string, use :class:`Literal` or :class:`Keyword`.
pyparsing includes helper strings for building Words:
- :class:`alphas`
- :class:`nums`
- :class:`alphanums`
- :class:`hexnums`
- :class:`alphas8bit` (alphabetic characters in ASCII range 128-255
- accented, tilded, umlauted, etc.)
- :class:`punc8bit` (non-alphabetic characters in ASCII range
128-255 - currency, symbols, superscripts, diacriticals, etc.)
- :class:`printables` (any non-whitespace character)
Example::
# a word composed of digits
integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
# a word with a leading capital, and zero or more lowercase
capital_word = Word(alphas.upper(), alphas.lower())
# hostnames are alphanumeric, with leading alpha, and '-'
hostname = Word(alphas, alphanums + '-')
# roman numeral (not a strict parser, accepts invalid mix of characters)
roman = Word("IVXLCDM")
# any string of non-whitespace characters, except for ','
csv_value = Word(printables, excludeChars=",")
Nr r Fc J t t | rSt d fd|D }|r!d fd|D }|| _ t | | _ |r || _ t | | _ n|| _ t | | _ |dk | _ |dk rt d || _ |dk r|| _ n t | _ |dk r|| _ || _ t | | _ d| j z | _ d| _ || _ d | j | j z vr2|dk r-|dk r(|dk r#| j | j k r d
t' | j z | _ nt+ | j dk r7t- j | j d t' | j d | _ n2d t' | j d
t' | j d | _ | j rd| j z dz | _ t- j | j | _ | j j | _ t6 | _ d S # t: $ r d | _ Y d S w xY wd S d S d S d S )Nr c 3 $ K | ]
}|v|V d S r r r r excludeCharss r r z Word.__init__..H s- N Na 8M8M8M8M8M8M N Nr c 3 $ K | ]
}|v|V d S r r r s r r z Word.__init__..J s- #R#R!A\ r
) r r r minmaxexactr r r> s `r r z
Word.__init__D s
dD""$$$ S |,,L N N N N9 N N NNNI
S GG#R#R#R#Ry#R#R#R R R & Y ,!*D ^^DNN!*D ^^DN !G 77 yzz z 77 DKK"DK 199 DK DK$KK !DI- "" d(4+== = =3!88PSWXPXPX]bfg]g]g!T%777 '*@AS*T*T T
T'((A---/Yt7I-J-J-J-J-CDDV-W-W-W-W!Z
. 0FdFX/Y/Y/Y/Y/EdFX/Y/Y/Y/Y!\
~
> %
5 =
, *T]33 !%
!+
> =88PXPX]g]gs J JJTc || | j vrt ||| j | |}|dz
}t | }| j }|| j z }t
|| }||k r || |v r|dz
}||k r
|| |v d}||z
| j k rd}nF| j r||k r
|| |v rd}n,| j r%|dk r
||dz
|v s||k r || |v rd}|rt ||| j | |||| fS )Nr FTr )
r rE ra r r r r r r r ) r r r rz r r bodycharsr throwExceptions r r
zWord.parseImpl} sY C= . . 3 TBB B qx==N $VX&&Fllx} 9 9 1HC Fllx} 9 9 ; $ $ !NN
&3>>hsmy6P6P !NN
^ & huqy 1Y > >X~~(3-9*D*D!% C 3 TBB BHU3Y'''r c < t t | S # t $ r Y nw xY w| j Vd }| j | j k r+d || j d || j d| _ nd || j z | _ | j S )Nc F t | dk r
| d d dz S | S )N r r )r s r
charsAsStrz Word.__str__..charsAsStr s( q66A:: RaR55=( Hr zW:(r r zW:(%s))r rU r r
rU r r )r r r> s r r z Word.__str__ s t$$,,.. . D <
!T%7777/9z$:L/M/M/M/MzzZ^ZlOmOmOmOm n '**T5G*H*H H | &*
77)Nr r r FNr r r r r r r
r r r s @r rU rU sv 3 3h7, 7, 7, 7, 7, 7,r( ( ( (8 r rU c e Zd ZddZdS )r Tc | || }|st ||| j | | }|| fS r )r rE ra endgroup)r r r rz r s r r
z_WordRegex.parseImpl sT x-- C 3 TBB BjjllFLLNN""r Nr r r r r r r s( # # # # # #r r c $ e Zd ZdZd fd Z xZS )rY zA short-cut class for defining ``Word(characters, exact=1)``,
when defining a match of any single character in a string of
characters.
FNc > t t | |d|| dt d | j z | _ |rd| j z | _ t j | j | _ | j j | _
d S )Nr )r r r [%s]r z\b%s\b) r rY r r r r r r r r r )r charsetr r r> s r r z
Char.__init__ s
dD""7!yWc"ddd !78O8O!P!PP
6 %
5DM*T]++
r )FNr r s @r rY rY sG & & & & & & & & & &r rY c L e Zd ZdZd fd Zd dZd dZd dZ fd Zd
Z xZ
S )
rM ah Token for matching strings that match a given regular
expression. Defined with string specifying the regular expression in
a form recognized by the stdlib Python `re module `_.
If the given regex contains named groups (defined using ``(?P...)``),
these will be preserved as named parse results.
If instead of the Python stdlib re module you wish to use a different RE module
(such as the `regex` module), you can replace it by either building your
Regex object with a compiled RE that was compiled using regex:
Example::
realnum = Regex(r"[+-]?\d+\.\d*")
date = Regex(r'(?P\d{4})-(?P\d\d?)-(?P\d\d?)')
# ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
roman = Regex(r"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
# use regex module instead of stdlib re module to construct a Regex using
# a compiled regular expression
import regex
parser = pp.Regex(regex.compile(r'[0-9]'))
r Fc ^ t t | t |t r|s t j dt d || _ || _ t j | j | j | _
| j | _ n# t j $ r! t j d|z t d w xY wt |d r2t |d r"|| _
|j x| _ | _ || _ nt! d | j
j | _ t' | | _ d| j z | _ d | _ | d
d u| _ || _ || _ | j r | j | _ | j r| j | _ d S d S ) a The parameters ``pattern`` and ``flags`` are passed
to the ``re.compile()`` function as-is. See the Python
`re module `_ module for an
explanation of the acceptable patterns and flags.
z0null string passed to Regex; use Empty() insteadr r $invalid pattern (%s) passed to Regexpatternr zCRegex may only be constructed with a string or a compiled RE objectrj Fr N) r rM r r rU r r r r flagsr r r
sre_constantserrorr rW r r r rF ra r` r[ asGroupListasMatchparseImplAsGroupListr
parseImplAsMatch)r r r r r r> s r r zRegex.__init__ s eT##%%% gz * * c
;
P +; ; ; ; #DL DJ
*T\4:>> $
&
Dw N +; ; ; ;
Wi
(
( cWWg-F-F c DG+2? :DL4= DJJ abb b
$KK !DI- " "mmB / /t ;& 7 ! 6DN < 3 ! 2DNNN 3 3s +0B 0C Tc < | || }|st ||| j | | }t | }| }|r | D ]
\ }}|||< ||fS r )r rE ra r rH r groupdictrh ) r r r rz r r dr` r\ s r r
zRegex.parseImpl
s x-- C 3 TBB Bjjll6<<>>**
1ACxr c | || }|st ||| j | | }| }||fS r )r rE ra r groupsr r r rz r r s r r zRegex.parseImplAsGroupList
sW x-- C 3 TBB BjjllmmooCxr c | || }|st ||| j | | }|}||fS r )r rE ra r r
s r r zRegex.parseImplAsMatch!
sO x-- C 3 TBB BjjllCxr c t t | S # t $ r Y nw xY w| j dt | j z | _ | j S )NzRe:(%s))r rM r r
rU r= r r s r r z
Regex.__str__*
sl %%--// / D < $tDL'9'99DL|r c 8 j r*t j dt d t j r9t
r*t j dt d t j rfd}n fd} | S )a
Return Regex with an attached parse action to transform the parsed
result as if called using `re.sub(expr, repl, string) `_.
Example::
make_html = Regex(r"(\w+):(.*?):").sub(r"<\1>\2")
print(make_html.transformString("h1:main title:"))
# prints "main title
"
z-cannot use sub() with Regex(asGroupList=True)r r z9cannot use sub() with a callable with Regex(asMatch=True)c : | d S r< )expand)r repls r r zRegex.sub..paK
s ay''---r c F j | d S r< )r ra )r r r s r r zRegex.sub..paN
s w{{4333r )r r r r SyntaxErrorr r r )r r r s `` r ra z Regex.sub5
s MI'A
7
7
7
7 -- < HTNN MU'A
7
7
7
7 -- < 4
.
.
.
.
.
.
4
4
4
4
4
4""2&&&r )r FFr ) r r r r r r
r r r ra r r s @r rM rM s .+3 +3 +3 +3 +3 +3Z ' ' ' ' ' ' 'r rM c : e Zd ZdZ d fd Zd dZ fdZ xZS )
rK a&
Token for matching strings that are delimited by quoting characters.
Defined with the following parameters:
- quoteChar - string of one or more characters defining the
quote delimiting string
- escChar - character to escape quotes, typically backslash
(default= ``None``)
- escQuote - special quote sequence to escape an embedded quote
string (such as SQL's ``""`` to escape an embedded ``"``)
(default= ``None``)
- multiline - boolean indicating whether quotes can span
multiple lines (default= ``False``)
- unquoteResults - boolean indicating whether the matched text
should be unquoted (default= ``True``)
- endQuoteChar - string of one or more characters defining the
end of the quote delimited string (default= ``None`` => same as
quoteChar)
- convertWhitespaceEscapes - convert escaped whitespace
(``'\t'``, ``'\n'``, etc.) to actual whitespace
(default= ``True``)
Example::
qs = QuotedString('"')
print(qs.searchString('lsjdf "This is the quote" sldjf'))
complex_qs = QuotedString('{{', endQuoteChar='}}')
print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
sql_qs = QuotedString('"', escQuote='""')
print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
prints::
[['This is the quote']]
[['This is the "quote"']]
[['This is the quote with "embedded" quotes']]
NFTc " t t | }|s*t j dt d t ||}n@| }|s*t j dt d t | _ t | _
|d _ | _ t | _
| _ | _ | _ | _ |rpt$ j t$ j z _ t% j j dt/ j d |d urt/ | pdd _ nYd _ t% j j dt/ j d d |d urt/ | pdd _ t j d
k rY xj d d fd
t5 t j d
z
dd D z dz z
c_ |r% xj dt% j | z z
c_ |rF xj dt% j | z z
c_ t% j j dz _ xj dt% j j z z
c_ t% j j j _ j _ j j _ n8# t@ j! $ r& t j d j z t d w xY wtE _# d j# z _$ d _% d _& d S )Nz$quoteChar cannot be the empty stringr r z'endQuoteChar cannot be the empty stringr z(?:[^r r z\n\rr z|(?:z)|(?:c 3 K | ]C}t j j d | dt j | dV Dd S )Nz[^r )r r endQuoteCharr )r r r s r r z(QuotedString.__init__..
s| &Y &Y*+ 469T=NrPQr=R3S3S3S3S3I$J[\]J^3_3_3_3_'a &Y &Y &Y &Y &Y &Yr r r z|(?:%s)z|(?:%s.)z(.)z)*%sr rj FT)'r rK r r r r r r quoteCharr quoteCharLenfirstQuoteCharr endQuoteCharLenescCharescQuoteunquoteResultsconvertWhitespaceEscapesr MULTILINEDOTALLr r r r r re escCharReplacePatternr r r r r r r rF ra r` r[ ) r r r r multiliner r r! r> s ` r r zQuotedString.__init__y
s
lD!!**,,, OO%% M@-\] ^ ^ ^ ^ -- $LL'--//L
$
G cdeeee!mm#" NN 'l ( "< 0 0
,(@% s 1DJ.0i.G.G.G.G.DTEVWXEY.Z.Z.Z/6d/B/fG]^eGfGf/ljl/l/l oDLL DJ24)DN2K2K2K2K2HIZ[\I]2^2^2^2^3:$3F3jKabiKjKj3pnp3p3p sDL t ! !A % % LL &Y &Y &Y &Y/4S9J5K5Ka5OQRTV/W/W&Y &Y &Y Y Y Y[^_
`LL
? LLZ")H*=*= = >LL I LL[29W+=+= = >LL)+4<)@)@5)HD & 29T->#?#??@ j tz::DG LDM GMDMM " M@4<O'A
7
7
7
7
$KK !DI- " "s
$AL& &5Mc V || | j k r| || pd }|st ||| j | | }| }| j r|| j | j }t |t rd|v r>| j r7ddddd}| D ]\ }}|
|| } | j rt j | j d| }| j r |
| j | j }||fS )Nr r
)\trs z\fz\rz\g<1>)r r rE ra r r r r r r rU r! rh r r r ra r$ r r ) r r r rz r r ws_mapwslitwschars r r
zQuotedString.parseImpl
sJ # $"55V$--RU:V:V^Z^ C 3 TBB Bjjllllnn H d'$*>)>>?C#z**
H3;;4#@; # # # # F *0 9 9
v !kk% 8 8 < L &!;XsKKC = H ++dmT5FGGCCxr c t t | S # t $ r Y nw xY w| j d| j d| j | _ | j S )Nz quoted string, starting with z
ending with )r rK r r
rU r r r s r r zQuotedString.__str__
sr t,,4466 6 D < OS~~~_c_p_pqDL|r )NNFTNTr r r s @r rK rK R
s % %L JORV?# ?# ?# ?# ?# ?#B! ! ! !F r rK c 6 e Zd ZdZd fd Zd dZ fdZ xZS )
r. a Token for matching words composed of characters *not* in a given
set (will include whitespace in matched characters if not listed in
the provided exclusion set - see example). Defined with string
containing all disallowed characters, and an optional minimum,
maximum, and/or exact length. The default value for ``min`` is
1 (a minimum value < 1 is not valid); the default values for
``max`` and ``exact`` are 0, meaning no maximum or exact
length restriction.
Example::
# define a comma-separated-value as anything that is not a ','
csv_value = CharsNotIn(',')
print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
prints::
['dkls', 'lsdkjf', 's12 34', '@!#', '213']
r r c z t t | d| _ || _ |dk rt d || _ |dk r|| _ n t | _ |dk r|| _ || _ t | | _
d| j
z | _ | j dk | _ d| _
d S )NFr zfcannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permittedr rj )r r. r rX notCharsr& r r r r rF ra r[ r` )r r1 r r r r> s r r zCharsNotIn.__init__
s
j$ ((*** #
77 ] ^ ^
^ 77 DKK"DK 199 DK DK$KK !DI- #{a / "r Tc ` || | j v rt ||| j | |}|dz
}| j }t || j z t | }||k r || |vr|dz
}||k r
|| |v||z
| j k rt ||| j | |||| fS r )r1 rE ra r r r r )r r r rz r notcharsmaxlens r r
zCharsNotIn.parseImpl s C=DM ) ) 3 TBB B q=UT[(#h--88Fllx}H < < 1HC Fllx}H < < ; $ $ 3 TBB BHU3Y'''r c t t | S # t $ r Y nw xY w| j ?t | j dk rd| j d d z | _ nd| j z | _ | j S )Nr z
!W:(%s...)z!W:(%s))r r. r r
rU r r1 r s r r zCharsNotIn.__str__& s T**2244 4 D < 4=!!A%% +dmBQB.? ? (4= 8 |r )r r r r r r s @r r. r.
st &# # # # # #2( ( ( ( r r. c e Zd ZdZi dddddddd d
d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*Zd1 fd. Zd2d0Z xZS )3rT a Special matching class for matching whitespace. Normally,
whitespace is ignored by pyparsing grammars. This class is included
when some whitespace structures are significant. Define with
a string containing the whitespace characters to be matched; default
is ``" \t\r\n"``. Also takes optional ``min``,
``max``, and ``exact`` arguments, as defined for the
:class:`Word` class.
r zr' zr
zr) zr( z zu zu zu z u z u z
u z
u zu zu zu zu zz z zzzz)u u u u u u
r r c t t | _ d fd j D d d j D _ d _ d j z _ | _
|dk r| _ n t _ |dk r| _ | _
d S d S )Nr c 3 . K | ]}|j v |V d S r )
matchWhite)r r r s r r z!White.__init__..Y s/ '_'_aatF^F^F^F^F^F^'_'_r c 3 : K | ]}t j | V d S r )rT whiteStrsr s r r z!White.__init__..[ s) I IAU_Q / I I I I I Ir Trj r )
r rT r r; rE r rY rF r[ ra r r r )r wsr r r r> s ` r r zWhite.__init__V s
eT##%%% '_'_'_'_4?'_'_'_ _ _```WW I I I I III "!DI- 77 DKK"DK 199 DK DKKK 9r Tc j || | j vrt ||| j | |}|dz
}|| j z }t |t | }||k r)|| | j v r|dz
}||k r|| | j v ||z
| j k rt ||| j | |||| fS r )r; rE ra r r r r )r r r rz r r s r r
zWhite.parseImplj s C= / / 3 TBB B q$VS]]++Fllx} ? ? 1HC Fllx} ? ? ; $ $ 3 TBB BHU3Y'''r )r8 r r r r )r r r r r= r r
r r s @r rT rT 4 sT
f
g
f
f
f
8
'
0
;
;
<
<
)
(
'
#!
" (#
$ "!' (/
I2 (
(
(
(
(
(
(
(
(r rT c e Zd Z fdZ xZS )_PositionTokenc t t | | j j | _ d| _ d| _ d S r )r rA r r> r rF r[ r` r s r r z_PositionToken.__init__{ sA
nd##,,...N+ " "r r r r r r r s @r rA rA z s8 # # # # # # # # #r rA c 0 e Zd ZdZ fdZd ZddZ xZS )r5 zaToken to advance to a specific column of input text; useful for
tabular report scraping.
c d t t | || _ d S r )r r5 r r` )r colnor> s r r zGoToColumn.__init__ s*
j$ ((***r c ~ t || | j k rt | }| j r| || }||k rq|| rWt || | j k r>|dz
}||k r3|| rt || | j k >|S r )r` r r] r isspace)r r r r s r r zGoToColumn.preParse s sH ) )8}}H
:**8S99..Xc]%:%:%<%<.S(ASASW[W_A_A_q ..Xc]%:%:%<%<.S(ASASW[W_A_A_
r Tc t || }|| j k rt ||d| || j z |z
}||| }||fS )NzText not in expected columnr` rE )r r r rz thiscolnewlocr s r r
zGoToColumn.parseImpl s[ c8$$ TX 30MtTT Ttx ')sF{#s{r r )r r r r r r r
r r s @r r5 r5 se r r5 c * e Zd ZdZ fdZddZ xZS )r9 a Matches if current position is at the beginning of a line within
the parse string
Example::
test = '''\
AAA this line
AAA and this line
AAA but not this one
B AAA and definitely not this one
'''
for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
print(t)
prints::
['AAA', ' this line']
['AAA', ' and this line']
c d t t | d| _ d S )NzExpected start of line)r r9 r ra r s r r zLineStart.__init__ s*
i ''))). r Tc ` t || dk r|g fS t ||| j | r )r` rE ra r s r r
zLineStart.parseImpl s6 sH " "7N XsDK>>>r r r r s @r r9 r9 sV */ / / / /? ? ? ? ? ? ? ?r r9 c * e Zd ZdZ fdZddZ xZS )r8 zTMatches if current position is at the end of a line within the
parse string
c t t | | t j dd d| _ d S )Nr
r zExpected end of line)r r8 r rE rJ rF r ra r s r r zLineEnd.__init__ sR
gt %%'''
A I I$PR S STTT, r Tc |t | k r*|| dk r|dz dfS t ||| j | |t | k r|dz g fS t ||| j | )Nr
r r rE ra r s r r
zLineEnd.parseImpl s{ X }$$Qw}$$XsDKFFF
CMM
!
!7B; 3 TBB Br r r r s @r r8 r8 s^ - - - - -
C C C C C C C Cr r8 c * e Zd ZdZ fdZddZ xZS )rP zLMatches if current position is at the beginning of the parse
string
c d t t | d| _ d S )NzExpected start of text)r rP r ra r s r r zStringStart.__init__ s*
k4 ))+++. r Tc x |dk r1|| |d k rt ||| j | |g fS r< )r rE ra r s r r
zStringStart.parseImpl sC !88dmmHa0000$XsDKFFFBwr r r r s @r rP rP sV / / / / / r rP c * e Zd ZdZ fdZddZ xZS )rO zBMatches if current position is at the end of the parse string
c d t t | d| _ d S )NzExpected end of text)r rO r ra r s r r zStringEnd.__init__ s*
i ''))), r Tc |t | k rt ||| j | |t | k r|dz g fS |t | k r|g fS t ||| j | r rS r s r r
zStringEnd.parseImpl sx X 3 TBB B
CMM
!
!7B;
3x==
7N 3 TBB Br r r r s @r rO rO s^ - - - - -C C C C C C C Cr rO c . e Zd ZdZef fd ZddZ xZS )rW ay Matches if the current position is at the beginning of a Word,
and is not preceded by any character in a given set of
``wordChars`` (default= ``printables``). To emulate the
```` behavior of regular expressions, use
``WordStart(alphanums)``. ``WordStart`` will also match at
the beginning of the string being parsed, or at the beginning of
a line.
c t t | t | | _ d| _ d S )NzNot at the start of a word)r rW r r wordCharsra r r\ r> s r r zWordStart.__init__ s7
i ''))) Y 2 r Tc |dk r8||dz
| j v s|| | j vrt ||| j | |g fS rd )r\ rE ra r s r r
zWordStart.parseImpl sQ !88q!T^33 }DN::$XsDKFFFBwr r r r r r r} r r
r r s @r rW rW s` ", 3 3 3 3 3 3
r rW c . e Zd ZdZef fd ZddZ xZS )rV a_ Matches if the current position is at the end of a Word, and is
not followed by any character in a given set of ``wordChars``
(default= ``printables``). To emulate the ```` behavior of
regular expressions, use ``WordEnd(alphanums)``. ``WordEnd``
will also match at the end of the string being parsed, or at the end
of a line.
c t t | t | | _ d| _ d| _ d S )NFzNot at the end of a word)r rV r r r\ rX ra r] s r r zWordEnd.__init__ s?
gt %%''' Y #0 r Tc t | }|dk r>||k r8|| | j v s||dz
| j vrt ||| j | |g fS rd )r r\ rE ra )r r r rz r s r r
zWordEnd.parseImpl sd x== a<.* s, BBD:dJ//BBBBBBr c 3 p K | ]0}t |t r | n|V 1d S r )r rU rK )r r r s r r z+ParseExpression.__init__..+ sG hh]^
1j8Q8QX11!444WXhhhhhhr F)r rF r r rR rP rU rK exprsrJ r r rW rd r rg rf r> s ` r r zParseExpression.__init__ s8
ot$$--h777 e^ , , KKE eZ ( ( % 22599:DJJ
}
-
- % DJJ
x
(
(
%KKEBBEBBBBB
ihhhhbghhh eDJJ
% !%[[
%
%
% #W
% !s ?D D)(D)c H | j | d | _ | S r )rg r rU r s r r zParseExpression.append4 s$
% r c | d| _ d | j D | _ | j D ]}| | S )zExtends ``leaveWhitespace`` defined in base class, and also invokes ``leaveWhitespace`` on
all contained expressions.Fc 6 g | ]}| S r r r r s r r z3ParseExpression.leaveWhitespace..= s 3331affhh333r )rX rg rC )r r s r rC z ParseExpression.leaveWhitespace9 sN $33
333
A
r c t |t r\|| j vrRt t | | | j D ]"}| | j d #nRt t | | | j D ]"}| | j d #| S r| )r rQ r] r rF rI rg )r r r r> s r rI zParseExpression.ignoreB s eX & & /D ,,,ot,,33E::: 3 3AHHT -b 12222 /4 ( ( / / 6 6 6Z
/
/)"-.... r c t t | S # t $ r Y nw xY w| j )| j j dt | j d| _ | j S Nz:(r ) r rF r r
rU r> r r rg r s r r zParseExpression.__str__N s} $//7799 9 D < (,(?(?(?tzARARARARSDL|r c t t | | j D ]}| t | j dk r| j d }t || j ri|j sb|j [|j sT|j d d | j d gz | _ d | _
| xj |j z c_ | xj |j z c_ | j d }t || j rj|j sc|j \|j sU| j d d |j d d z | _ d | _
| xj |j z c_ | xj |j z c_ dt | z | _ | S )Nr r r r rj )r rF r rg r r r> rS rV r^ rU r[ r` r ra )r r r r> s r r zParseExpression.streamlineX s
ot$$//111 A
LLNNNN
tz??a JqME5$.11
; ! -
; )1 !K 2 "[^tz!}o =
# ##u';;##""u'::""JrNE5$.11
; ! -
; )1 !K 2 !Z_u{111~ =
# ##u';;##""u'::""!E$KK/ r Nc ||ng d d | gz }| j D ]}| | | g d S r )rg rX rU )r rW tmpr s r rX zParseExpression.validatez s\ - 9}}r111EN A
JJsOOOO B r c t t | }d | j D |_ |S )Nc 6 g | ]}| S r r rl s r r z(ParseExpression.copy.. s 222!QVVXX222r )r rF r rg r r r> s r r zParseExpression.copy s: OT**//1122tz222
r c
@ t j ri| j D ]a}t |t rJ|j rCt
j d d|t | j
|j d bt t |
|| S )N]{0}: setting results name {1!r} on {2} expression collides with {3!r} on contained expressionr# r r )r! r# rg r rJ rV r r r r r r rF ro r rF rp r r> s r ro z ParseExpression._setResultsName s = 0Z
0
0 a // 0AM 0 M #PPVPV XCW[W[\`WaWaWjWXWdQf Qf ./ 0 0 0 0 _d++;;D.QQQr r r )r r r r r r rC rI r r rX r ro r r s @r rF rF s " " " " " ",
D
R R R R R R R R R Rr rF c d e Zd ZdZ G d de Zd fd Z fdZd dZd Z d Z
d
Z xZ S ) r+ a
Requires all given :class:`ParseExpression` s to be found in the given order.
Expressions may be separated by whitespace.
May be constructed using the ``'+'`` operator.
May also be constructed using the ``'-'`` operator, which will
suppress backtracking.
Example::
integer = Word(nums)
name_expr = OneOrMore(Word(alphas))
expr = And([integer("id"), name_expr("name"), integer("age")])
# more easily written as:
expr = integer("id") + name_expr("name") + integer("age")
c e Zd Z fdZ xZS )And._ErrorStopc t t j | j |i | d| _ | d S )N-)r r+ r r rF rC )r r r r> s r r zAnd._ErrorStop.__init__ sF 0E#.$ ' ' 0$ A& A A ADI " " " " "r rC r s @r r r{ s8 # # # # # # # # #r r Tc t | }|rt |v rg }t | D ]\ }}|t u rv|t | dz
k rQt ||dz z j d }| t | d ut d | | ||d d < t t | || t d | j D | _
| | j d j | j d j | _ d| _ d S )Nr r r z0cannot construct And with sequence ending in ...c 3 $ K | ] }|j V d S r r[ rl s r r z And.__init__.. % !G!Gq!"2!G!G!G!G!G!Gr r T)rP r r r r2 rg r rN r
r r+ r r r[ rE rY rX rd )r rg rf rr r r
skipto_argr> s r r z And.__init__ sT U X&&C$U++
%
%48##3u::>))&+gga!e &<%CB%G
#56*#5#5k#B#BCCCC '(Z [ [[JJt$$$$E!!!H
c4!!%222 !!G!GDJ!G!G!G G G
1
8999 "jm : r c J | j rt d | j d d D rt | j d d D ]w\ }}|t |t rZ|j rSt |j d t
r3|j d | j |dz z |j d< d | j |dz < xd | j D | _ t
t | t d | j D | _
| S )Nc 3 K | ]@}t |t o&|j o t |j d t V AdS r N)r rF rg r rl s r r z!And.streamline.. s^ - - a 11gagg*QWUW[ZfBgBg - - - - - -r r r c g | ]}||S r r rl s r r z"And.streamline.. s E E EAq}a}}}r c 3 $ K | ] }|j V d S r r rl s r r z!And.streamline.. r r ) rg r r r rF r r r+ r r r[ )r r r r> s r r zAnd.streamline s3 :
F - - JssO- - - - -
F %dj"o 6 6 1 1DAqy "1o66 1 !1,6qwr{L,Q,Q1&'gbkDJq1u4E&E ,0
1q5) E E E E E
c4##%%% !!G!GDJ!G!G!G G G r c 4 | j d |||d \ }}d}| j dd D ]}t |t j rd} |r | ||| \ }}n# t
$ r t $ r&}d |_ t
| d }~wt $ r% t |t | | j | w xY w| ||| \ }}|s| r||z
}||fS )Nr Fr r T)
rg r r r+ r rI rC r r rX r ra r ) r r r rz
resultlist errorStopr
exprtokensr s r r
z
And.parseImpl s` *Q-..xiV[.\\Z ABB ) )A!S^,,
E[&'hhxi&H&HOC+ ) C C C'+B$.>>rBBB! [ [ [.xX UYZZZ[ #$((8S)"D"DZ
)Z / / 1 1
)j(
J s A66C
!B++2C c t |t r| | }| | S r r rU rK r r s r r z And.__iadd__ 9 eZ ( ( 4,,U33E{{5!!!r c t |d d | gz }| j D ]!}| | |j s d S "d S r )rg rU r[ r r/ subRecCheckListr s r rU zAnd.checkRecursion s] *111-6 A
_ - - -#
r c t | d r| j S | j /dd d | j D z dz | _ | j S )NrF {r c 3 4 K | ]}t | V d S r r rl s r r z And.__str__.. s( )G)Gq%(()G)G)G)G)G)Gr }r rF rU r rg r s r r z And.__str__ sZ 4 9 < )G)GDJ)G)G)G!G!GG#MDL|r r )
r r r r r2 r r r r
r rU r r r s @r r+ r+ s "# # # # #U # # # ! ! ! ! ! !( $ 2" " "
r r+ c T e Zd ZdZd fd Z fdZd dZd Zd Zd Z d fd
Z
xZ S )
rB a Requires that at least one :class:`ParseExpression` is found. If
two expressions match, the expression that matches the longest
string will be used. May be constructed using the ``'^'``
operator.
Example::
# construct Or using '^' operator
number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
print(number.searchString("123 3.1416 789"))
prints::
[['123'], ['3.1416'], ['789']]
Fc t t | || | j r%t d | j D | _ d S d| _ d S )Nc 3 $ K | ] }|j V d S r r rl s r r z Or.__init__.. % %K%K1a&6%K%K%K%K%K%Kr T)r rB r rg r r[ rh s r r z Or.__init__ s`
b$ 111 : '"%%K%K
%K%K%K"K"KD "&D r c t t | t j r#t d | j D | _ | S )Nc 3 $ K | ] }|j V d S r rW rl s r r z Or.streamline.. $ !C!C1!,!C!C!C!C!C!Cr )r rB r r* collect_all_And_tokensr rg rW r s r r z
Or.streamline sN
b$""$$$ , D !!C!C
!C!C!C C CDO r Tc x d}d }g }| j D ]} | || }| ||f 1# t $ r%} d | _ | j |k r | }| j }Y d } ~ [d } ~ wt $ rI t | |k r3t |t | |j | }t | }Y w xY w|r| t d d |s%|d d }
|
||| S d} |D ]~\ } }
| | d k r| c S |
||| \ }}|| k r||fc S || d k r||f} M# t $ r%} d | _ | j |k r | }| j }Y d } ~ wd } ~ ww xY w| dk r| S || j |_ |t ||d| )Nr r T)r rg r r no defined alternatives to match)
rg r r rE r r rX r ra sortr r r )r r r rz maxExcLoc maxExceptionr r loc2r best_exprlongestloc1expr1r! s r r
z Or.parseImpl sG * *A
*zz(C00 ay)))) "
(
(
($(!7Y&&#&L #I
.
.
.x==9,,#1(CMM18UY#Z#ZL #H
I
.
LLZ]]DL 9 9 9
B $AJqM ''#yAAA G &
-
- e71:%%"NNN -!& hY!G!GJD$ t|| #Tz)))
**"&* & , , ,(,C%w**'* $'G , *$$ # #{L 30RTXYY Ys4 ?
B? A))AB?>B?)E
F*F
Fc t |t r| | }| | S r r r s r __ixor__z Or.__ixor__[ r r c t | d r| j S | j /dd d | j D z dz | _ | j S )NrF r z ^ c 3 4 K | ]}t | V d S r r rl s r r z Or.__str__..e ( +I+IE!HH+I+I+I+I+I+Ir r r r s r r z
Or.__str__` Z 4 9 < +I+Idj+I+I+I!I!IICODL|r c ` |d d | gz }| j D ]}| | d S r rg rU r s r rU zOr.checkRecursioni I *111-6 . .A
_ - - - - . .r c < t j sgt j r[t d | j D r=t
j d d|t | j
d t t |
|| S )Nc 3 @ K | ]}t |t V d S r r r+ rl s r r z%Or._setResultsName..q , ::!:a%%::::::r {0}: setting results name {1!r} on {2} expression may only return a single token for an And alternative, in future will return the full list of tokensr" r r )r* r r! r" r rg r r r r r r rB ro r rF rp r> s r ro zOr._setResultsNamen s 1 " F "::tz:::::
"
NNTf?tDzzGZO\ O\ " " " " R..t^DDDr r r ) r r r r r r r
r r rU ro r r s @r rB rB s ' ' ' ' ' ' :Z :Z :Z :Zz" " "
. . .
E
E
E
E
E
E
E
E
E
Er rB c T e Zd ZdZd fd Z fdZd dZd Zd Zd Z d fd
Z
xZ S )
r< a Requires that at least one :class:`ParseExpression` is found. If
two expressions match, the first one listed is the one that will
match. May be constructed using the ``'|'`` operator.
Example::
# construct MatchFirst using '|' operator
# watch the order of expressions to match
number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
print(number.searchString("123 3.1416 789")) # Fail! -> [['123'], ['3'], ['1416'], ['789']]
# put more selective expression first
number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
print(number.searchString("123 3.1416 789")) # Better -> [['123'], ['3.1416'], ['789']]
Fc t t | || | j r%t d | j D | _ d S d| _ d S )Nc 3 $ K | ] }|j V d S r r rl s r r z&MatchFirst.__init__.. r r T)r r< r rg r r[ rh s r r zMatchFirst.__init__ sb
j$ ((999 : '"%%K%K
%K%K%K"K"KD "&D r c t t | t j r#t d | j D | _ | S )Nc 3 $ K | ] }|j V d S r r rl s r r z(MatchFirst.streamline.. r r )r r< r r* r r rg rW r s r r zMatchFirst.streamline sP
j$ **,,, , D !!C!C
!C!C!C C CDO r Tc d}d }| j D ]} | ||| }|c S # t $ r }|j |k r |}|j }Y d }~Ad }~wt $ rI t | |k r3t |t | |j | }t | }Y w xY w|| j |_ |t ||d| )Nr r )rg r rE r rX r ra r ) r r r rz r r r r r s r r
zMatchFirst.parseImpl s ^ ^A
.hhxi88
!
(
(
(7Y&&#&L #I
.
.
.x==9,,#1(CMM18UY#Z#ZL #H
I
. '#'; ""$Xs4VX\]]]s *
B#A
AB#"B#c t |t r| | }| | S r r r s r __ior__zMatchFirst.__ior__ r r c t | d r| j S | j /dd d | j D z dz | _ | j S )NrF r | c 3 4 K | ]}t | V d S r r rl s r r z%MatchFirst.__str__.. r r r r r s r r zMatchFirst.__str__ r r c ` |d d | gz }| j D ]}| | d S r r r s r rU zMatchFirst.checkRecursion r r c < t j sgt j r[t d | j D r=t
j d d|t | j
d t t |
|| S )Nc 3 @ K | ]}t |t V d S r r rl s r r z-MatchFirst._setResultsName.. r r r r" r r )r* r r! r" r rg r r r r r r r< ro r s r ro zMatchFirst._setResultsName s 1 " F "::tz:::::
"
NNTf?tDzzGZO\ O\ " " " " Z&&66t^LLLr r r ) r r r r r r r
r r rU ro r r s @r r< r< { s ' ' ' ' ' ' ^ ^ ^ ^0" " "
. . .
M
M
M
M
M
M
M
M
M
Mr r< c B e Zd ZdZd fd Z fdZddZd Zd Z xZ S ) r1 as Requires all given :class:`ParseExpression` s to be found, but in
any order. Expressions may be separated by whitespace.
May be constructed using the ``'&'`` operator.
Example::
color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
integer = Word(nums)
shape_attr = "shape:" + shape_type("shape")
posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
color_attr = "color:" + color("color")
size_attr = "size:" + integer("size")
# use Each (using operator '&') to accept attributes in any order
# (shape and posn are required, color and size are optional)
shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
shape_spec.runTests('''
shape: SQUARE color: BLACK posn: 100, 120
shape: CIRCLE size: 50 color: BLUE posn: 50,80
color:GREEN size:20 shape:TRIANGLE posn:20,40
'''
)
prints::
shape: SQUARE color: BLACK posn: 100, 120
['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
- color: BLACK
- posn: ['100', ',', '120']
- x: 100
- y: 120
- shape: SQUARE
shape: CIRCLE size: 50 color: BLUE posn: 50,80
['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
- color: BLUE
- posn: ['50', ',', '80']
- x: 50
- y: 80
- shape: CIRCLE
- size: 50
color: GREEN size: 20 shape: TRIANGLE posn: 20,40
['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
- color: GREEN
- posn: ['20', ',', '40']
- x: 20
- y: 40
- shape: TRIANGLE
- size: 20
Tc t t | || t d | j D | _ d| _ d| _ d| _ d S )Nc 3 $ K | ] }|j V d S r r rl s r r z Each.__init__.. r r T) r r1 r r rg r[ rX initExprGroupsrW rh s r r z
Each.__init__
s_
dD""5(333 !!G!GDJ!G!G!G G G " " r c t t | t d | j D | _ | S )Nc 3 $ K | ] }|j V d S r r rl s r r z"Each.streamline.. r r )r r1 r r rg r[ r s r r zEach.streamline sE
dD$$&&& !!G!GDJ!G!G!G G G r c | j rt d | j D | _ d | j D }d | j D }||z | _ d | j D | _ d | j D | _ d | j D | _ | xj | j z
c_ d| _ |}| j d d }| j d d g }d} | r|z | j z | j z }
g } |
D ]} | || }| | j
t | | | |v r| | n| v r | # t $ r | | Y w xY wt | t |
k rd} | |r3d d
|D }
t ||d |
z |fd | j D z
}g }|D ]1} | ||| \ }}| | 2t# |t% g }||fS )
Nc 3 l K | ]/}t |t t |j |fV 0d S r )r rA rh r rl s r r z!Each.parseImpl.. s? _ _AzRSU]G^G^ _AFQ _ _ _ _ _ _r c F g | ] }t |t |j S r r rA r rl s r r z"Each.parseImpl.. s) JJJq*Q2I2IJAFJJJr c X g | ]'}|j t |t t f %|(S r )r[ r rA rM rl s r r z"Each.parseImpl.. s7 ggg!Q-=gjQRU]_dTeFfFfgAgggr c F g | ] }t |t |j S r )r rX r rl s r r z"Each.parseImpl.. s) "["["[aAzAZAZ"[16"["["[r c F g | ] }t |t |j S r )r r? r rl s r r z"Each.parseImpl.. s) !Y!Y!YQ
1i@X@X!Y!&!Y!Y!Yr c V g | ]&}t |t t t f $|'S r )r rA rX r? rl s r r z"Each.parseImpl.. s0 k k k1*QS]_hHi:j:j kQ k k kr FTr c 3 4 K | ]}t | V d S r r rl s r r z!Each.parseImpl..9 s( : :Qa : : : : : :r z*Missing one or more required elements (%s)c P g | ]"}t |t |j v |#S r r )r r tmpOpts r r z"Each.parseImpl..= s5 ]]]Q
1h0G0G]AFV\L\L\qL\L\L\r )r rS rg opt1map optionalsmultioptionals
multirequiredrequiredr r r rh removerE r r r sumrH )r r r rz opt1opt2tmpLoctmpReqd
matchOrder keepMatchingtmpExprsfailedr missingr r finalResultsr s @r r
zEach.parseImpl s ( _ _ _ _ ___DLJJDJJJJDggtzgggD !D[DN"["[4:"["["[D !Y!Y$*!Y!Y!YD k k
k k kDM MMT / /MM"'D -".#
% '$*==@RRHF
)
) ) ZZ& 9 9F %%dl&6&6r!uua&@&@AAAG|| q))))f
a((( & % % %MM!$$$$$% 6{{c(mm++ $ %" hii : :' : : :::G 30\_f0fgg g ]]]]$*]]]]
' 'A 88Hc9==LC g & & & &:|B'7'788 L s 8E== F F c t | d r| j S | j /dd d | j D z dz | _ | j S )NrF r z & c 3 4 K | ]}t | V d S r r rl s r r z Each.__str__..L r r r r r s r r z Each.__str__G r r c ` |d d | gz }| j D ]}| | d S r r r s r rU zEach.checkRecursionP r r r )
r r r r r r r
r rU r r s @r r1 r1 s 7 7p
/! /! /! /!b . . . . . . .r r1 c ^ e Zd ZdZd
fd ZddZd Z fdZ fdZd Z dd Z
fd Z xZ S )rD zfAbstract subclass of :class:`ParserElement`, for combining and
post-processing parsed tokens.
Fc 4 t t | | t |t rRt | j t r| | }n"| t | }|| _ d | _
|w|j | _ |j | _ |
|j |j | _ |j | _ |j | _ | j |j d S d S r )r rD r r rU
issubclassrK rR r: r rU r` r[ rE rY rX rW rd r] r r r rf r> s r r z ParseElementEnhance.__init__Z s
!4((11(;;; dJ ' ' ?$2E::
?//55//
>> !%!3D "&"5D # #DO 4 4 4"&"5D "oDO $ 1D # #D$4 5 5 5 5 5 r Tc z | j | j |||d S t d|| j | )NFr r )r r rE ra r s r r
z ParseElementEnhance.parseImpll s? 9 9##Hc95#QQ Q S$+t<< #INN$$ 9 I % % ' ' ' r c t |t r^|| j vrTt t | | | j %| j | j d nTt t | | | j %| j | j d | S r| )r rQ r] r rD rI r r r r> s r rI zParseElementEnhance.ignorey s eX & & 7D ,,,)40077>>>9(I$$T%5b%9::: %t , , 3 3E : : :y$ !1"!5666 r c t t | | j | j | S r )r rD r r r s r r z ParseElementEnhance.streamline sA
!4((33555 9 I " " " r c | |v rt || gz |d d | gz }| j | j | d S d S r )rL r rU )r r/ r s r rU z"ParseElementEnhance.checkRecursion se # # #+,<v,EFF F*111-6 9 I $ $_ 5 5 5 5 5 ! r Nc |g }|d d | gz }| j | j | | g d S r r rX rU r rW rr s r rX z ParseElementEnhance.validate sZ MAAA $' 9 I s # # # B r c t t | S # t $ r Y nw xY w| j 0| j )| j j dt | j d| _ | j S ro ) r rD r r
rU r r> r r r s r r zParseElementEnhance.__str__ s ,d33;;== = D < DI$9(,(?(?(?tyAQAQAQAQRDL|r r r r )
r r r r r r
rC rI r rU rX r r r s @r rD rD V s 6 6 6 6 6 6$= = = =
6 6 6 r rD c * e Zd ZdZ fdZddZ xZS )r3 ab Lookahead matching of the given parse expression.
``FollowedBy`` does *not* advance the parsing position within
the input string, it only verifies that the specified parse
expression matches at the current position. ``FollowedBy``
always returns a null token list. If any results names are defined
in the lookahead expression, those *will* be returned for access by
name.
Example::
# use FollowedBy to match a label only if it is followed by a ':'
data_word = Word(alphas)
label = data_word + FollowedBy(':')
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
prints::
[['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
c f t t | | d| _ d S r )r r3 r r[ r r r> s r r zFollowedBy.__init__ s/
j$ ((... "r Tc T | j ||| \ }}|d d = ||fS )Nr )r r )r r r rz _r s r r
zFollowedBy.parseImpl s8 !!(C9!EE3 FCxr r r r s @r r3 r3 sV *# # # # # r r3 c , e Zd ZdZd fd ZddZ xZS ) r; ap Lookbehind matching of the given parse expression.
``PrecededBy`` does not advance the parsing position within the
input string, it only verifies that the specified parse expression
matches prior to the current position. ``PrecededBy`` always
returns a null token list, but if a results name is defined on the
given expression, it is returned.
Parameters:
- expr - expression that must match prior to the current parse
location
- retreat - (default= ``None``) - (int) maximum number of characters
to lookbehind prior to the current parse location
If the lookbehind expression is a string, Literal, Keyword, or
a Word or CharsNotIn with a specified exact or maximum length, then
the retreat parameter is not required. Otherwise, retreat must be
specified to give a maximum number of characters to look back from
the current parse position for a lookbehind match.
Example::
# VB-style variable names with type prefixes
int_var = PrecededBy("#") + pyparsing_common.identifier
str_var = PrecededBy("$") + pyparsing_common.identifier
Nc t t | | | | _ d| _ d| _ d| _ t |t rt | }d| _ nt |t t f r|j
}d| _ nYt |t t f r |j t" k r|j }d| _ n t |t$ r d}d| _ || _ dt | z | _ d| _ | j d d S )NTFr znot preceded by c H | t d d S r )ro r] r r r s r r z%PrecededBy.__init__.. s
eD$>O>O0P0P r )r r; r r rC r[ r` r r r r r: r7 r rU r. r r rA retreatra rX rS r )r r r r> s r r zPrecededBy.__init__ s3
j$ ((...IIKK//11 " "
dC $iiG DJJ
w 0
1
1 mG DJJ
tZ 0
1
1 dkX6M6MkG DJJ
n
-
- G DJ (3t994 # P PQQQQQr r Tc ( | j rJ|| j k rt ||| j || j z
}| j || \ }}n| j t
z }|t d|| j z
| }t ||| j } t dt || j dz dz D ]F}
| |t | |
z
\ }} n# t $ r } | } Y d } ~ ?d } ~ ww xY w| ||fS rd ) r r rE ra r r rO r re r r rC ) r r r rz r r r test_exprinstring_slice last_exprr pbes r r
zPrecededBy.parseImpl s= : T\!!$XsDK@@@$,&EY%%h66FAss IKK/I %c!S4<-?&@&@&D EN&xdkBBI 3sDL1,<#=#=a#?@@
& - -nc.>Q>QTZ>Z [ [FAs E * $ $ $ #IIIIII$
Cxs
)C55
D ?DD r )r Tr r s @r r; r; sa 6R R R R R R. r r; c 0 e Zd ZdZ fdZddZd Z xZS )r> a Lookahead to disallow matching with the given parse expression.
``NotAny`` does *not* advance the parsing position within the
input string, it only verifies that the specified parse expression
does *not* match at the current position. Also, ``NotAny`` does
*not* skip over leading whitespace. ``NotAny`` always returns
a null token list. May be constructed using the '~' operator.
Example::
AND, OR, NOT = map(CaselessKeyword, "AND OR NOT".split())
# take care not to mistake keywords for identifiers
ident = ~(AND | OR | NOT) + Word(alphas)
boolean_term = Optional(NOT) + ident
# very crude boolean expression - to support parenthesis groups and
# operation hierarchy, use infixNotation
boolean_expr = boolean_term + ZeroOrMore((AND | OR) + boolean_term)
# integers that are followed by "." are actually floats
integer = Word(nums) + ~Char(".")
c t t | | d| _ d| _ dt | j z | _ d S )NFTzFound unwanted token, )r r> r rX r[ r r ra r s r r zNotAny.__init__* sK
fd$$T*** # ".ty1A1AA r Tc n | j || rt ||| j | |g fS r )r r rE ra r s r r
zNotAny.parseImpl1 s< 9 ! !(C 0 0 C 3 TBB BBwr c t | d r| j S | j dt | j z dz | _ | j S )NrF z~{r r rF rU r r r s r r zNotAny.__str__6 sG 4 9 < % "2"22S8DL|r r r r s @r r> r> sj ,B B B B B
r r> c : e Zd Zd fd Zd Zd dZd
fd Z xZS ) _MultipleMatchNc t t | | d| _ |}t |t
r| | }| | d S r )r r r rW r rU rK stopOn)r r r enderr> s r r z_MultipleMatch.__init__@ sj
nd##,,T222 eZ ( ( 4,,U33E Er c r t |t r| | }|| nd | _ | S r )r rU rK not_ender)r r s r r z_MultipleMatch.stopOnH s> eZ ( ( 4,,U33E#(#4%$ r Tc x | j j }| j }| j d u}|r | j j }|r ||| ||||d \ }} | j } |r ||| | r
||| }
n|}
|||
| \ }} | s| r|| z
}K# t t f$ r Y nw xY w||fS NFr ) r r r r r r] r rE rX ) r r r rz self_expr_parseself_skip_ignorables check_ender
try_not_enderr hasIgnoreExprsr tmptokenss r r
z_MultipleMatch.parseImplN s2 )* # 3 nD0 4 N 3M ) M(C ( ( (%ohYUSSS V
&*&6"6 6N
( 1!M(C000! ! 1 1(C @ @FF F!0 69!M!MY ( 1 1 3 3 (i'F
(
+ D F{s AB! !B54B5Fc
p t j r| j gt | j dg z D ]a}t |t
rJ|j rCt j d d|t | j |j d bt t | || S )Nrg rw r# r r )r! r# r r@ r rJ rV r r r r r r r ro rx s r ro z _MultipleMatch._setResultsNamek s = 0i[749gr#B#BB
0
0 a // 0AM 0 M #PPVPV XCW[W[\`WaWaWjWXWdQf Qf ./ 0 0 0 0 ^T**::4 PPPr r r r )r r r r r r
ro r r s @r r r ? s : Q Q Q Q Q Q Q Q Q Qr r c e Zd ZdZd ZdS )r? aj Repetition of one or more of the given expression.
Parameters:
- expr - expression that must match one or more times
- stopOn - (default= ``None``) - expression for a terminating sentinel
(only required if the sentinel would ordinarily match the repetition
expression)
Example::
data_word = Word(alphas)
label = data_word + FollowedBy(':')
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
text = "shape: SQUARE posn: upper left color: BLACK"
OneOrMore(attr_expr).parseString(text).pprint() # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
# use stopOn attribute for OneOrMore to avoid reading label string as part of the data
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
# could also be written as
(attr_expr * (1,)).parseString(text).pprint()
c t | d r| j S | j dt | j z dz | _ | j S )NrF r z}...r
r s r r zOneOrMore.__str__ G 4 9 < ty!1!11F:DL|r N)r r r r r r r r r? r? y s- 2 r r? c 6 e Zd ZdZd fd Zd fd Zd Z xZS ) rX ak Optional repetition of zero or more of the given expression.
Parameters:
- expr - expression that must match zero or more times
- stopOn - (default= ``None``) - expression for a terminating sentinel
(only required if the sentinel would ordinarily match the repetition
expression)
Example: similar to :class:`OneOrMore`
Nc j t t | || d| _ d S )Nr T)r rX r r[ )r r r r> s r r zZeroOrMore.__init__ s4
j$ ((f(=== "r Tc t t | ||| S # t t f$ r |g fcY S w xY wr )r rX r
rE rX )r r r rz r> s r r
zZeroOrMore.parseImpl sW T**44XsINN N
+ 7NNN s )- AAc t | d r| j S | j dt | j z dz | _ | j S )NrF r ]...r
r s r r zZeroOrMore.__str__ r r r r r r s @r rX rX st # # # # # # r rX c e Zd Zd ZeZd ZdS )
_NullTokenc dS r r r s r rv z_NullToken.__bool__ s ur c dS r r r s r r z_NullToken.__str__ s rr N)r r r rv r r r r r r( r( s7 K r r( c H e Zd ZdZ e Zef fd ZddZd Z xZ S )rA aG Optional matching of the given expression.
Parameters:
- expr - expression that must match zero or more times
- default (optional) - value to be returned if the optional expression is not found.
Example::
# US postal code can be a 5-digit zip, plus optional 4-digit qualifier
zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
zip.runTests('''
# traditional ZIP code
12345
# ZIP+4 form
12101-0001
# invalid ZIP
98765-
''')
prints::
# traditional ZIP code
12345
['12345']
# ZIP+4 form
12101-0001
['12101-0001']
# invalid ZIP
98765-
^
FAIL: Expected end of text (at char 5), (line:1, col:6)
c t t | |d | j j | _ || _ d| _ d S )NFr T)r rA r r rW r r[ )r r r r> s r r zOptional.__init__ sH
h &&te&<<< ). # "r Tc | j |||d \ }}nf# t t f$ rR | j | j ur?| j j r*t | j g }| j || j j < n | j g}ng }Y nw xY w||fS r )r r rE rX r _Optional__optionalNotMatchedrV rH )r r r rz r s r r
zOptional.parseImpl s
)**8S)RW*XXKC
+ (AAA9( 1 )4+<*= > >F484EF49011 " / 0FF F{s !$ A BBc t | d r| j S | j dt | j z dz | _ | j S )NrF r r r
r s r r zOptional.__str__ sG 4 9 < ty!1!11C7DL|r r )
r r r r r( r. r r
r r r s @r rA rA s| # #H &:<<%9 # # # # # # r rA c , e Zd ZdZd fd ZddZ xZS ) rN a Token for skipping over all undefined text until the matched
expression is found.
Parameters:
- expr - target expression marking the end of the data to be skipped
- include - (default= ``False``) if True, the target expression is also parsed
(the skipped text and target expression are returned as a 2-element list).
- ignore - (default= ``None``) used to define grammars (typically quoted strings and
comments) that might contain false matches to the target expression
- failOn - (default= ``None``) define expressions that are not allowed to be
included in the skipped test; if found before the target expression is found,
the SkipTo is not a match
Example::
report = '''
Outstanding Issues Report - 1 Jan 2000
# | Severity | Description | Days Open
-----+----------+-------------------------------------------+-----------
101 | Critical | Intermittent system crash | 6
94 | Cosmetic | Spelling error on Login ('log|n') | 14
79 | Minor | System slow when running too many reports | 47
'''
integer = Word(nums)
SEP = Suppress('|')
# use SkipTo to simply match everything up until the next SEP
# - ignore quoted strings, so that a '|' character inside a quoted string does not match
# - parse action will call token.strip() for each matched token, i.e., the description body
string_data = SkipTo(SEP, ignore=quotedString)
string_data.setParseAction(tokenMap(str.strip))
ticket_expr = (integer("issue_num") + SEP
+ string_data("sev") + SEP
+ string_data("desc") + SEP
+ integer("days_open"))
for tkt in ticket_expr.searchString(report):
print tkt.dump()
prints::
['101', 'Critical', 'Intermittent system crash', '6']
- days_open: 6
- desc: Intermittent system crash
- issue_num: 101
- sev: Critical
['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
- days_open: 14
- desc: Spelling error on Login ('log|n')
- issue_num: 94
- sev: Cosmetic
['79', 'Minor', 'System slow when running too many reports', '47']
- days_open: 47
- desc: System slow when running too many reports
- issue_num: 79
- sev: Minor
FNc D t t | | || _ d| _ d| _ || _ d| _ t |t r|
| | _ n|| _ dt | j
z | _ d S )NTFzNo match found for )r rN r
ignoreExprr[ r` includeMatchrW r rU rK failOnr r ra )r r includerI r4 r> s r r zSkipTo.__init__@ s
fd$$U+++ " " # fj ) ) ! 226::DKK DK+eDI.>.>> r Tc |}t | }| j }| j j }| j | j j nd }| j | j j nd } |}
|
|k rd|
|||
rnl| | ||
}
n# t $ r Y nw xY w |||
dd n9# t t f$ r |
dz
}
Y nw xY w|
|k dt ||| j
| |
}||| } t | } | j r ||||d \ }}
| |
z
} || fS )Nr F)rz r{ r )
r r r r4 r r2 r rC rE rX ra rH r3 )r r r rz r r r
expr_parseself_failOn_canParseNextself_ignoreExpr_tryParsetmplocskiptext
skipresultr s r r
zSkipTo.parseImplM s x==yY%
?C{?V4;#;#;\` ?C?Z4?#;#;`d '3++Hf== '3 !9!9(F!K!K-
8Vu5QQQQ #J/
!
! 2 !3 TBB B HSL)!(++
!z(COOOHC # JJ s$ * A7 7
BB B B21B2)FNNr r r s @r rN rN s\ 8 8r ? ? ? ? ? ?- - - - - - - - r rN c ` e Zd ZdZd
fd Zd Zd Zd Zd Zd
dZ d Z
fd
Z d fd Z xZ
S )r4 a_ Forward declaration of an expression to be defined later -
used for recursive grammars, such as algebraic infix notation.
When the expression is known, it is assigned to the ``Forward``
variable using the '<<' operator.
Note: take care when assigning to ``Forward`` not to overlook
precedence of operators.
Specifically, '|' has a lower precedence than '<<', so that::
fwdExpr << a | b | c
will actually be evaluated as::
(fwdExpr << a) | b | c
thereby leaving b and c out as parseable alternatives. It is recommended that you
explicitly group the values inserted into the ``Forward``::
fwdExpr << (a | b | c)
Converting to use the '<<=' operator instead will avoid this problem.
See :class:`ParseResults.pprint` for an example of a recursive
parser created using ``Forward``.
Nc \ t t | |d d S r )r r4 r r s r r zForward.__init__ s,
gt %%ee%<<<< r )r retStrings r r zForward.__str__ s 4 9 < #< Fy$ !$) , ,UdU 3 " >2T9IEDLL4>2T9IEDL E E E E|s &A. .Bc | j 't t | S t }|| z }|S r )r r r4 r ru s r r z Forward.copy s> 9 $'',,.. .))C DLCJr Fc t j rD| j =t j d d|t
| j d t t |
|| S )NzR{0}: setting results name {0!r} on {1} expression that has no contained expressionr$ r r ) r! r$ r r r r r r r r4 ro r s r ro zForward._setResultsName s 2 ,y
AAGHhHLHLT
H[B] B] *+ , , , , Wd##33D.IIIr r r )r r r r r r@ rB rC r rX r r ro r r s @r r4 r4 | s 4= = = = = = ( J J J J J J J J J Jr r4 c $ e Zd ZdZd fd Z xZS )rS zW
Abstract subclass of :class:`ParseExpression`, for converting parsed results.
Fc f t t | | d| _ d S r )r rS r rW r s r r zTokenConverter.__init__ s,
nd##,,T222 r r r r s @r rS rS sG r rS c 4 e Zd ZdZd fd Z fdZd Z xZS )r/ a Converter to concatenate all matching tokens to a single string.
By default, the matching patterns must also be contiguous in the
input string; this can be disabled by specifying
``'adjacent=False'`` in the constructor.
Example::
real = Word(nums) + '.' + Word(nums)
print(real.parseString('3.1416')) # -> ['3', '.', '1416']
# will also erroneously match the following
print(real.parseString('3. 1416')) # -> ['3', '.', '1416']
real = Combine(Word(nums) + '.' + Word(nums))
print(real.parseString('3.1416')) # -> ['3.1416']
# no match when there are internal spaces
print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
r Tc t t | | |r| || _ d| _ || _ d| _ d S r )r r/ r rC adjacentrX
joinStringrd )r r rP rO r> s r r zCombine.__init__ s_
gt %%d+++ # " " "
"$ r c | j r t | | n(t t | | | S r )rO rJ rI r r/ r s r rI zCombine.ignore
sI = / u - - - - '4 ' ' . . . r c | }|d d = |t d | | j g| j z
}| j r| r|gS |S )Nr )rH )r rH r r rP rb rV r )r r r r retTokss r r zCombine.postParse s .."" AAAJ<)@)@ )Q)Q!R!R S[_[lmmmm 1 1 9 Nr )r T)r r r r r rI r r r s @r r/ r/ so "! ! ! ! ! ! r r/ c ( e Zd ZdZ fdZd Z xZS )r6 a Converter to return the matched tokens as a list - useful for
returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions.
Example::
ident = Word(alphas)
num = Word(nums)
term = ident | num
func = ident + Optional(delimitedList(term))
print(func.parseString("fn a, b, 100")) # -> ['fn', 'a', 'b', '100']
func = ident + Group(Optional(delimitedList(term)))
print(func.parseString("fn a, b, 100")) # -> ['fn', ['a', 'b', '100']]
c f t t | | d| _ d S r )r r6 r rW r s r r zGroup.__init__* s,
eT##D))) r c |gS r r r s r r zGroup.postParse. s
{r r r r r r r r r s @r r6 r6 sQ
r r6 c ( e Zd ZdZ fdZd Z xZS )r0 a? Converter to return a repetitive expression as a list, but also
as a dictionary. Each element can also be referenced using the first
token in the expression as its key. Useful for tabular report
scraping when the first column can be used as a item key.
Example::
data_word = Word(alphas)
label = data_word + FollowedBy(':')
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
# print attributes as plain groups
print(OneOrMore(attr_expr).parseString(text).dump())
# instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
print(result.dump())
# access named fields as dict entries, or output as dict
print(result['shape'])
print(result.asDict())
prints::
['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
[['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
- color: light blue
- posn: upper left
- shape: SQUARE
- texture: burlap
SQUARE
{'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
See more examples at :class:`ParseResults` of accessing fields by results name.
c f t t | | d| _ d S r )r r0 r rW r s r r z
Dict.__init__X s,
dD""4((( r c t | D ]N\ }}t | dk r|d }t |t r't |d }t | dk rt
d| ||< t | dk r5t |d t st
|d | ||< | }|d= t | dk s)t |t r)| rt
|| ||< 5t
|d | ||< P| j
r|gS |S )Nr r r r ) r r r r r r r2 rH r r rV )r r r r r tokikey dictvalues r r zDict.postParse\ sR ** O OFAs3xx1}}q6D$$$
- SV}}**,,3xx1}}"9"a"@"@ $SQ z#a&,'G'G "9#a&!"D"D $ HHJJ aLy>>Q&&:i +N+N&S\SdSdSfSf&&=i&K&KIdOO&=ilA&N&NIdOO ; r rW r s @r r0 r0 1 sR % %L r r0 c e Zd ZdZd Zd ZdS )rQ a[ Converter for ignoring the results of a parsed expression.
Example::
source = "a, b, c,d"
wd = Word(alphas)
wd_list1 = wd + ZeroOrMore(',' + wd)
print(wd_list1.parseString(source))
# often, delimiters that are useful during parsing are just in the
# way afterward - use Suppress to keep them out of the parsed output
wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
print(wd_list2.parseString(source))
prints::
['a', ',', 'b', ',', 'c', ',', 'd']
['a', 'b', 'c', 'd']
(See also :class:`delimitedList`.)
c g S r r r s r r zSuppress.postParse s r c | S r r r s r r@ zSuppress.suppress s r N)r r r r r r@ r r r rQ rQ u s< * r rQ c $ e Zd ZdZd Zd Zd ZdS )r@ zDWrapper for parse actions, to ensure they are only called once.
c < t | | _ d| _ d S r )r r called)r
methodCalls r r zOnlyOnce.__init__ s #J//
r c r | j s | ||| }d| _ |S t ||d )NTr )rc r rE )r r r r r s r r> zOnlyOnce.__call__ s? { mmAq!,,G DKN Q2&&&r c d| _ d S r )rc r s r resetzOnlyOnce.reset s
r N)r r r r r r> rg r r r r@ r@ sK ' ' ' r r@ c l t fd} j |_ n# t $ r Y nw xY w|S )aq Decorator for debugging parse actions.
When the parse action is called, this decorator will print
``">> entering method-name(line:, , )"``.
When the parse action completes, the decorator will print
``"<<"`` followed by the returned value, or any exception that the parse action raised.
Example::
wd = Word(alphas)
@traceParseAction
def remove_duplicate_chars(tokens):
return ''.join(sorted(set(''.join(tokens))))
wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
prints::
>>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
<>entering %s(line: '%s', %d, %r)
z
< r stderrrw rn r
)paArgsthisFuncr r r r r r_ s r zztraceParseAction..z s :+1a v;;?? ay*3c9HDH
>(DQRTUJJXY[\A]]^^^ !V*CC J 333 O P P P
xxxEFFF
s 7A= =
B3'B..B3)r r r )r_ rn s ` r r r s^ 2 AA
Z
Hs $
11,c J t | dz t | z dz t | z dz }|r5t | t || z z | S | t t | | z z | S )a Helper to define a delimited list of expressions - the delimiter
defaults to ','. By default, the list elements and delimiters can
have intervening whitespace, and comments, but this can be
overridden by passing ``combine=True`` in the constructor. If
``combine`` is set to ``True``, the matching tokens are
returned as a single token string, with the delimiters included;
otherwise, the matching tokens are returned as a list of tokens,
with the delimiters suppressed.
Example::
delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
z [r r& )r r/ rX rm rQ )r delimcombinedlNames r rg rg s 4[[4
%,,
.
4uT{{
BV
KF Ktj 6 6677??GGGz(5//D"8999BB6JJJr c Z t fd}|)t t d }n| }| d | |d |z dt z dz S ) a> Helper to define a counted list of expressions.
This helper defines a pattern of the form::
integer expr expr expr...
where the leading integer tells how many expr expressions follow.
The matched tokens returns the array of expr tokens as a list - the
leading count token is suppressed.
If ``intExpr`` is specified, it should be a pyparsing expression
that produces an integer value.
Example::
countedArray(Word(alphas)).parseString('2 ab cd ef') # -> ['ab', 'cd']
# in this parser, the leading integer value is given in binary,
# '10' indicating that 2 values are in the array
binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef') # -> ['ab', 'cd']
c |d }|r t t g|z pt t z g S r< )r6 r+ rj )r r r r# arrayExprr s r countFieldParseActionz+countedArray..countFieldParseAction s@
aDa2E#tfqj// 2 2BeEllCC r Nc , t | d S r< )r r s r r z countedArray.. s c!A$ii r arrayLenTre z(len) r )r4 rU ry r r rm r r )r intExprrw rv s ` @r rc rc s . I t**++,?,?@@,,.. OOJ 0EEE i ( (E$KK)?%)G H HHr c g }| D ]O}t |t r#| t | :| | P|S r )r rP r r r )Lr r s r r r
sY
C
a JJx{{ # # # # JJqMMMM Jr c t fd}| |d dt | z S )a4 Helper to define an expression that is indirectly defined from
the tokens matched in a previous expression, that is, it looks for
a 'repeat' of a previous expression. For example::
first = Word(nums)
second = matchPreviousLiteral(first)
matchExpr = first + ":" + second
will match ``"1:1"``, but not ``"1:2"``. Because this
matches a previous literal, will also match the leading
``"1:1"`` in ``"1:10"``. If this is not desired, use
:class:`matchPreviousExpr`. Do *not* use with packrat parsing
enabled.
c |r_t | dk r
|d z d S t | }t d |D z d S t z d S )Nr r c 3 4 K | ]}t | V d S r )r: r tts r r zDmatchPreviousLiteral..copyTokenToRepeater..* s( 77272;;777777r )r r rG r+ r2 )r r r tflatreps r copyTokenToRepeaterz1matchPreviousLiteral..copyTokenToRepeater# s{ 1vv{{qt !,,s77777777777 577NNNNr Trz (prev) )r4 r rm r )r r r s @r rv rv se ))C +4@@@KK E$KK'((( Jr c t | }|z fd}| |d dt | z S )aT Helper to define an expression that is indirectly defined from
the tokens matched in a previous expression, that is, it looks for
a 'repeat' of a previous expression. For example::
first = Word(nums)
second = matchPreviousExpr(first)
matchExpr = first + ":" + second
will match ``"1:1"``, but not ``"1:2"``. Because this
matches by expressions, will *not* match the leading ``"1:1"``
in ``"1:10"``; the expressions are evaluated first, and then
compared, so ``"1"`` is compared with ``"10"``. Do *not* use
with packrat parsing enabled.
c t | fd} |d d S )Nc x t | }|k rt ddd d S )Nr r )r rG rE )r r r theseTokens matchTokenss r mustMatchTheseTokenszLmatchPreviousExpr..copyTokenToRepeater..mustMatchTheseTokensE s= "188::..Kk))$RB/// *)r Trz )r rG r )r r r r r r s @r r z.matchPreviousExpr..copyTokenToRepeaterC sT qxxzz** 0 0 0 0 0 /tDDDDDr Trz r )r4 r r rm r )r e2r r s @r ru ru 1 s ))C
BBJCE E E E E +4@@@KK E$KK'((( Jr c dD ] }| |t |z } !| dd } | dd } t | S )Nz\^-[]r
rs r' r* )r _bslashr )r r s r r r N s[
& &
IIa1 % % $ A $ A 88Or c t |t rt j dd |rd }d }|rt nt
nd }d }|rt nt g }t | t r| }nAt | t rt | }n t j dt d |st S |sd }|t | d
z
k r|| }t ||d
z d D ]I\ } }
||
| r ||| z d
z = n3 |||
r!||| z d
z = | ||
nJ|d
z
}|t | d
z
k |s
|s
|r t | t d | k rUt# d
d d |D z d | S t# d d |D d | S # t& $ r t j dt d Y nw xY wt) fd|D d | S )a Helper to quickly define a set of alternative Literals, and makes
sure to do longest-first testing when there is a conflict,
regardless of the input order, but returns
a :class:`MatchFirst` for best performance.
Parameters:
- strs - a string of space-delimited literals, or a collection of
string literals
- caseless - (default= ``False``) - treat all literals as
caseless
- useRegex - (default= ``True``) - as an optimization, will
generate a Regex object; otherwise, will generate
a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if
creating a :class:`Regex` raises an exception)
- asKeyword - (default=``False``) - enforce Keyword-style matching on the
generated expressions
Example::
comp_oper = oneOf("< = > <= >= !=")
var = Word(alphas)
number = Word(nums)
term = var | number
comparison_expr = term + comp_oper + term
print(comparison_expr.searchString("B = 12 AA=23 B<=AA AA>12"))
prints::
[['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
z_More than one string argument passed to oneOf, pass choices as a list or space-delimited stringr r c V | | k S r )r r bs r r zoneOf..{ s QWWYY 6 r c t | | S r )r r r s r r zoneOf..| s$ aggii 2 217799 = = r c | |k S r r r s r r zoneOf.. s
Q r c , | | S r r r s r r zoneOf.. s all1oo r z6Invalid argument to oneOf, expected string or iterabler r Nr r c 3 4 K | ]}t | V d S r )r r syms r r zoneOf.. s+ -]-]c.DS.I.I-]-]-]-]-]-]r r |c 3 > K | ]}t j | V d S r )r r r s r r zoneOf.. s* %H%Hbinn%H%H%H%H%H%Hr z7Exception creating Regex for oneOf, building MatchFirstc 3 . K | ]} | V d S r r )r r parseElementClasss r r zoneOf.. s/ @@'',,@@@@@@r )r rU r r r, r- r7 r: r r rP r r= r r r r rM rm r
r< ) strsr useRegexr isequalmaskssymbolsr currl r r s @r rz rz V sA @ (J'' S
DPQ S S S S >66==/8 MOOo&&--'0 =GGgG$
## 3**,, D( # # 3t**
N# 3 3 3 3 yy
#g,,"""!*C %ga!effo 6 6
575#&& A *EU3&& A *NN1e,,,E
Q #g,,"""
1 1x 1 17||s2777#3#3 4 444 Vbgg-]-]U\-]-]-]&]&] ]^^ffglgqgqrygzgz{{{ SXX%H%H%H%H%H H HIIQQRWR\R\]dReRefff 1 1 1 MS!a
1
1
1
1
1
1 1
@@@@@@@ @ @ H HT[I\I\ ] ]]s BI AI &JJc Z t t t | |z S )a Helper to easily and clearly define a dictionary by specifying
the respective patterns for the key and value. Takes care of
defining the :class:`Dict`, :class:`ZeroOrMore`, and
:class:`Group` tokens in the proper order. The key pattern
can include delimiting markers or punctuation, as long as they are
suppressed, thereby leaving the significant key text. The value
pattern can include named results, so that the :class:`Dict` results
can include named token fields.
Example::
text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
print(OneOrMore(attr_expr).parseString(text).dump())
attr_label = label
attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
# similar to Dict, but simpler call format
result = dictOf(attr_label, attr_value).parseString(text)
print(result.dump())
print(result['shape'])
print(result.shape) # object attribute access works too
print(result.asDict())
prints::
[['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
- color: light blue
- posn: upper left
- shape: SQUARE
- texture: burlap
SQUARE
SQUARE
{'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
)r0 r? r6 )r rm s r rh rh s' J %e ,,-- . ..r c t d }| }d|_ |d | z |d z }|rd }nd }| | | j |_ |S )a Helper to return the original, untokenized text for a given
expression. Useful to restore the parsed fields of an HTML start
tag into the raw tag text itself, or to revert separate tokens with
intervening whitespace back to the original matching input text. By
default, returns astring containing the original parsed text.
If the optional ``asString`` argument is passed as
``False``, then the return value is
a :class:`ParseResults` containing any results names that
were originally matched, and a single token containing the original
matched text from the input string. So if the expression passed to
:class:`originalTextFor` contains expressions with defined
results names, you must set ``asString`` to ``False`` if you
want to preserve those results name values.
Example::
src = "this is test bold text normal text "
for tag in ("b", "i"):
opener, closer = makeHTMLTags(tag)
patt = originalTextFor(opener + SkipTo(closer) + closer)
print(patt.searchString(src)[0])
prints::
[' bold text ']
['text']
c |S r r )r r r s r r z!originalTextFor.. s r F_original_start
_original_endc * | |j |j S r )r r r s r r z!originalTextFor.. s a(91?(J&K r c r | | d | d g|d d < d S )Nr r )r r s r extractTextz$originalTextFor..extractText s9 aee -..quu_/E/EEFGAaaaDDDr )r2 r r rd r] )r asString locMarker endlocMarker matchExprr s r r r s : &&'<'<==I >>##L %L +,,t3ll?6S6SSI HKK H H H
[))) ,I r c H t | d S )zkHelper to undo pyparsing's default grouping of And expressions,
even if all but one are non-empty.
c | d S r< r r s r r zungroup.. s
1 r )rS r )r s r r r s" $ . .~~ > >>r c t d }t |d | d z | d z S )a Helper to decorate a returned token with its starting and ending
locations in the input string.
This helper adds the following results names:
- locn_start = location where matched expression begins
- locn_end = location where matched expression ends
- value = the actual parsed results
Be careful if the input text contains ```` characters, you
may want to call :class:`ParserElement.parseWithTabs`
Example::
wd = Word(alphas)
for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
print(match)
prints::
[[0, 'ljsdf', 5]]
[[8, 'lksdjjf', 15]]
[[18, 'lkkjj', 23]]
c |S r r r s r r z locatedExpr.. s Q r
locn_startrm locn_end)r2 r r6 r rC )r locators r r r si 2 gg$$%6%677G &&g 69Y 9W9W9Y9YZd9e9ee f ffr rj rp ro r r z\[]-*.$+^?()~ r c |d d S rd r r s r r r ( s XYZ[X\]^X_ r z\\0?[xX][0-9a-fA-F]+c n t t |d d d S )Nr z\0xr )unichrr rx r s r r r ) s1 PVWZ[\]^[_[f[fgm[n[nprWsWsPtPt r z \\0[0-7]+c X t t |d dd d S )Nr r )r r r s r r r * s, VCPQRSPTUVUWUWPXZ[L\L\E]E] r z\]r} r r negatebodyr c d d fdt | j D S # t $ r Y dS w xY w)a Helper to easily define string ranges for use in Word
construction. Borrows syntax from regexp '[]' string range
definitions::
srange("[0-9]") -> "0123456789"
srange("[a-z]") -> "abcdefghijklmnopqrstuvwxyz"
srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
The input string must be enclosed in []'s, and the returned string
is the expanded character set joined into a single string. The
values enclosed in the []'s may be:
- a single character
- an escaped character with a leading backslash (such as ``\-``
or ``\]``)
- an escaped hex character with a leading ``'\x'``
(``\x21``, which is a ``'!'`` character) (``\0x##``
is also supported for backwards compatibility)
- an escaped octal character with a leading ``'\0'``
(``\041``, which is a ``'!'`` character)
- a range of any of the above, separated by a dash (``'a-z'``,
etc.)
- any combination of the above (``'aeiouy'``,
``'a-zA-Z0-9_$'``, etc.)
c
t | t s| nUd d t t | d t | d dz D S )Nr c 3 4 K | ]}t | V d S r r r s r r z+srange....I s* KKZ[FSTIIKKKKKKr r r )r rH r re ord)ps r r zsrange..I se :a #>#>!!BGGKK_dehijklimenenpstuvwtxpypy|}p}_~_~KKKDD r r c 3 . K | ]} | V d S r r )r part _expandeds r r zsrange..K s+ VV4yyVVVVVVr )r _reBracketExprr r r
)r r s @r r r / sm 4 @IwwVVVV>3M3Ma3P3P3UVVVVVV rrs =A
AAc fd}|S )zoHelper method for defining parse actions that require matching at
a specific column in the input text.
c X t || k rt | |dz d S )Nz matched token not at column %drJ )r locnr! r# s r verifyColz!matchOnlyAtCol..verifyColS s7 tT??a t-MPQ-QRR R r r )r# r s ` r rt rt O s) S S S S S r c fdS )a Helper method for common parse actions that simply return
a literal value. Especially useful when used with
:class:`transformString