U
|
G=®dw ã i @ sÖ d Z dZdZdZddlZddlmZ ddlZddl Z ddl
|
Z
|
ddl Z ddl Z ddl Z ddlZddlZddlZddlmZ zddlmZ W n ek
|
r¨ ddlmZ Y nX z dd lmZ dd
|
lmZ W n, ek
|
rò dd l mZ dd
|
l mZ Y nX zdd l mZ W nB ek
|
rF zdd lmZ W n ek
|
r@ dZY nX Y nX d d ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtgiZ e e j ddu
Z e d dukZ e rpe j!Z"e#Z$e%Z&e#Z'e(e)e*e+e,e e-e.e/e0e1g Z2n`e j3Z"e4Z5dvdw Z'g Z2ddl6Z6dx 7¡ D ]8Z8ze2 9e:e6e8¡ W n e;k
|
rÊ Y qY nX qe<dydz e5d{D Z=d|d} Z>G d~d de?Z@ejAejB ZCdZDeDd ZEeCeD ZFe%dZGd Hddz ejID ¡ZJG d
d# d#eKZLG dd% d%eLZMG dd' d'eLZNG dd) d)eNZOG dd, d,eKZPG dd de?ZQG dd( d(e?ZRe SeR¡ dd? ZTddP ZUddM ZVdd ZWdd ZXdd ZYddW ZZd/ddZ[G dd* d*e?Z\G dd2 d2e\Z]G dd de]Z^G dd d e]Z_G dd de]Z`e`Zae`e\_bG dd de]ZcG d d de`ZdG d¡d d ecZeG d¢dr dre]ZfG d£d5 d5e]ZgG d¤d- d-e]ZhG d¥d+ d+e]ZiG d¦d de]ZjG d§d4 d4e]ZkG d¨d© d©e]ZlG dªd delZmG d«d delZnG d¬d delZoG dd0 d0elZpG d®d/ d/elZqG d¯d7 d7elZrG d°d6 d6elZsG d±d& d&e\ZtG d²d d etZuG d³d" d"etZvG d´d d etZwG dµd detZxG d¶d$ d$e\ZyG d·d deyZzG d¸d d eyZ{G d¹dº dºeyZ|G d»d d e|Z}G d¼d8 d8e|Z~G d½d¾ d¾e?Ze ZG d¿d! d!eyZG dÀd. d.eyZG dÁd deyZG dÂdà dÃeZG dÄd3 d3eyZ
G dÅd de
ZG dÆd de
ZG dÇd de
ZG dÈd1 d1e
ZG dÉd d e?ZdÊdh Zd0dÍdFZd1dÎdBZdÏdÐ ZdÑdU ZdÒdT ZdÓdÔ Zd2dÖdYZd×dG Zd3dØdmZdÙdn ZdÚdp Ze^ dI¡Zen dO¡Zeo dN¡Zep dg¡Zeq df¡ZegeGdÛddÜ dÝdÞ ¡Zehdß dàdÞ ¡Zehdá dâdÞ ¡Z eeB e B ejdãd{dÜB Z¡ee¡edä e¡ Z¢e`dåedæ £dç¡ ee}e¢e¡B £dè¡ dé Z¤dêde Z¥dëdS Z¦dìdb Z§díd` Z¨dîds Z©e©dïdÞ Zªe©dðdÞ Z«dñdò Z¬dódQ ZdôdR Z®dõdk Z¯e? e¯_°d4dödqZ±e@ Z²e? e²_³e? e²_´ed÷edøfdùdoZµeµZ¶eehdúdû dü¡Z·eehdýdþ dÿ¡Z¸eehdúdû ehdýdþ B d ¡Z¹eeade¹ ¡ d¡Zºd÷døde¹ ¡ fddVZ»d5ddlZ¼e¥dZ½e¥dZ¾eegeCeFd d¡\Z¿ZÀeÁeÂd 7¡ d
|
ZÃehd d Heà ġ ¡ d d¡ZÅdda ZÆeehdd d¡ZÇehd d¡ZÈehd É¡ d¡ZÊehd d¡ZËeehdd eËB d¡ZÌeÌZÍehd d¡ZÎee}egeJdËd eegd e`dË eo Ï¡ d ¡ZÐeee¹ ¡ eÐB dd d@¡ZÑG d dt dtZÒeÓd!k rÒedd"ZÔedd#ZÕegeCeFd$ ZÖeeÖd%dÕd& eª¡Z×eee× d'¡ZØd(eØB ZÙeeÖd%dÕd& eª¡ZÚeeeÚ d)¡ZÛeÔd*eÙd' eÕ eÛd) ZÜeÜ Ýd+¡ eÒjÞ Ýd,¡ eÒjß Ýd,¡ eÒjà Ýd-¡ ddláZáeÒjá e©eájâ¡ eÒjá Ýd.¡ dS (6 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
|
C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements
|
(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to
|
L{Literal} expressions)::
|
|
from 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 L{ParseResults} object returned from L{ParserElement.parseString<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 L{ParserElement} and L{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 L{Literal} and L{CaselessLiteral} classes
|
- construct character word-group expressions using the L{Word} class
|
- see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
|
- use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones
|
- associate names with your parsed results using L{ParserElement.setResultsName}
|
- find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
|
- find more useful common expressions in the L{pyparsing_common} namespace class
|
z2.2.1z18 Sep 2018 00:49 UTCz*Paul McGuire <ptmcg@users.sourceforge.net>é N)Úref)Údatetime)ÚRLock)ÚIterable)ÚMutableMapping)Ú OrderedDictÚAndÚCaselessKeywordÚCaselessLiteralÚ
|
CharsNotInÚCombineÚDictÚEachÚEmptyÚ
|
FollowedByÚForwardÚ
|
GoToColumnÚGroupÚKeywordÚLineEndÚ LineStartÚLiteralÚ
|
MatchFirstÚNoMatchÚNotAnyÚ OneOrMoreÚOnlyOnceÚOptionalÚOrÚParseBaseExceptionÚParseElementEnhanceÚParseExceptionÚParseExpressionÚParseFatalExceptionÚ ParseResultsÚParseSyntaxExceptionÚ ParserElementÚ QuotedStringÚRecursiveGrammarExceptionÚRegexÚSkipToÚ StringEndÚ StringStartÚSuppressÚTokenÚTokenConverterÚWhiteÚWordÚWordEndÚ WordStartÚ
|
ZeroOrMoreÚ alphanumsÚalphasÚ
|
alphas8bitÚ anyCloseTagÚ
|
anyOpenTagÚ cStyleCommentÚcolÚcommaSeparatedListÚcommonHTMLEntityÚ countedArrayÚcppStyleCommentÚdblQuotedStringÚdblSlashCommentÚ delimitedListÚdictOfÚdowncaseTokensÚemptyÚhexnumsÚ htmlCommentÚjavaStyleCommentÚlineÚlineEndÚ lineStartÚlinenoÚ makeHTMLTagsÚ makeXMLTagsÚmatchOnlyAtColÚmatchPreviousExprÚmatchPreviousLiteralÚ
|
nestedExprÚnullDebugActionÚnumsÚoneOfÚopAssocÚoperatorPrecedenceÚ
|
printablesÚpunc8bitÚpythonStyleCommentÚ quotedStringÚ removeQuotesÚreplaceHTMLEntityÚ replaceWithÚ
|
restOfLineÚsglQuotedStringÚsrangeÚ stringEndÚ stringStartÚtraceParseActionÚ unicodeStringÚ upcaseTokensÚ withAttributeÚ indentedBlockÚoriginalTextForÚungroupÚ infixNotationÚ locatedExprÚ withClassÚ
|
CloseMatchÚtokenMapÚpyparsing_commoné c C sf t | tr| S z
|
t| W S tk
|
r` t| t ¡ d¡}td}| dd ¡ | |¡ Y S X dS )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 S s$ dt t| d dd
dd
S )Nz\ur é éÿÿÿÿ)ÚhexÚint©Út© ry úVD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pkg_resources/_vendor/pyparsing.pyÚ<lambda>« ó z_ustr.<locals>.<lambda>N)
|
Ú
|
isinstanceÚunicodeÚstrÚUnicodeEncodeErrorÚencodeÚsysÚgetdefaultencodingr) ÚsetParseActionÚtransformString)ÚobjÚretZ
|
xmlcharrefry ry rz Ú_ustr s
|
|
r z6sum len sorted reversed list tuple set any all min maxc c s | ]
|
}|V qd S ©Nry )Ú.0Úyry ry rz Ú <genexpr>· s r é c C s: d}dd d ¡ D }t||D ]\}}| ||¡} q | S )z/Escape &, <, >, ", ', etc. in a string of data.z&><"'c s s | ]}d | d V qdS )ú&ú;Nry )r Úsry ry rz r ¾ s z _xml_escape.<locals>.<genexpr>zamp gt lt quot apos)ÚsplitÚzipÚreplace)ÚdataÚ from_symbolsÚ
|
to_symbolsÚfrom_Úto_ry ry rz Ú _xml_escape¹ s
|
r c @ s e Zd ZdS )Ú
|
_ConstantsN)Ú__name__Ú
|
__module__Ú __qualname__ry ry ry rz r à s r Ú
|
0123456789Z ABCDEFabcdefé\ Ú c c s | ]}|t jkr|V qd S r )ÚstringÚ
|
whitespace©r Úcry ry rz r Ë s
|
c @ sP e Zd ZdZdddZedd Zdd Zd
|
d Zd d Z dddZ
|
dd Z dS )r z7base exception class for all parsing runtime exceptionsr Nc C s> || _ |d kr || _d| _n || _|| _|| _|||f| _d S ©Nr )ÚlocÚmsgÚpstrÚ parserElementÚargs)Úselfr¨ r¦ r§ Úelemry ry rz Ú__init__Ñ s zParseBaseException.__init__c C s | |j |j|j|jS )z
|
internal factory method to simplify creating one type of ParseException
|
from another - avoids having __init__ signature conflicts among subclasses
|
)r¨ r¦ r§ r© )ÚclsÚpery ry rz Ú_from_exceptionÜ s z"ParseBaseException._from_exceptionc C sN |dkrt | j| jS |dkr,t| j| jS |dkrBt| j| jS t|dS )z÷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
|
rL )r; ÚcolumnrI N)rL r¦ r¨ r; rI ÚAttributeError)r« Úanamery ry rz Ú __getattr__ä s z ParseBaseException.__getattr__c C s d| j | j| j| jf S )Nz"%s (at char %d), (line:%d, col:%d))r§ r¦ rL r± ©r« ry ry rz Ú__str__ó s ÿzParseBaseException.__str__c C s t | S r ©r rµ ry ry rz Ú__repr__ö s zParseBaseException.__repr__ú>!<c C s< | j }| jd }|r4d |d|
|||d
f¡}| ¡ S )z
Extracts the exception line from the input string, and marks
|
the location of the exception with a special symbol.
|
r r N)rI r± ÚjoinÚstrip)r« Ú markerStringÚline_strÚ line_columnry ry rz Ú markInputlineø s
|
|
ÿz ParseBaseException.markInputlinec C s d ¡ tt| S )Nzlineno col line)r ÚdirÚtyperµ ry ry rz Ú__dir__ s zParseBaseException.__dir__)r NN)r¹ ) r r r Ú__doc__r Ú classmethodr° r´ r¶ r¸ r¿ r ry ry ry rz r Í s
|
|
|
|
c @ s e Zd ZdZdS )r! aN
|
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
|
N©r r r rà ry ry ry rz r! s c @ s e Zd ZdZdS )r# znuser-throwable exception thrown when inconsistent parse content
|
is found; stops all parsing immediatelyNrÅ ry ry ry rz r# s c @ s e Zd ZdZdS )r% zßjust like L{ParseFatalException}, but thrown internally when an
|
L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop
|
immediately because an unbacktrackable syntax error has been foundNrÅ ry ry ry rz r% s c @ s e Zd ZdZdd Zdd ZdS )r( zZexception thrown by L{ParserElement.validate} if the grammar could be improperly recursivec C s
|
|| _ d S r ©ÚparseElementTrace©r« ÚparseElementListry ry rz r 4 s z"RecursiveGrammarException.__init__c C s
|
d| j S )Nz RecursiveGrammarException: %srÆ rµ ry ry rz r¶ 7 s z!RecursiveGrammarException.__str__N)r r r rà r r¶ ry ry ry rz r( 2 s c @ s, e Zd Zdd Zdd Zdd Zdd Zd S )
|
Ú_ParseResultsWithOffsetc C s ||f| _ d S r ©Útup)r« Úp1Úp2ry ry rz r ; s z _ParseResultsWithOffset.__init__c C s
|
| j | S r rË ©r« Úiry ry rz Ú __getitem__= s z#_ParseResultsWithOffset.__getitem__c C s t | jd S ©Nr )ÚreprrÌ rµ ry ry rz r¸ ? s z _ParseResultsWithOffset.__repr__c C s | j d |f| _ d S rÒ rË rÏ ry ry rz Ú setOffsetA s z!_ParseResultsWithOffset.setOffsetN)r r r r rÑ r¸ rÔ ry ry ry rz rÊ : s rÊ c @ s e Zd ZdZd[ddZddddefddZdd Zefd
|
d Zd d Z dd Z
|
dd Z dd Z e Z dd Zdd Zdd Zdd Zd d ZereZeZeZn$eZeZeZd d Zd d! Zd"d# Zd$d% Zd&d' Zd\d(d)Z d*d+ Z d,d- Z d.d/ Z d0d1 Z d2d3 Z!d4d5 Z"d6d7 Z#d8d9 Z$d:d; Z%d<d= Z&d]d?d@Z'dAdB Z(dCdD Z)dEdF Z*d^dHdIZ+dJdK Z,dLdM Z-d_dOdPZ.dQdR Z/dSdT Z0dUdV Z1dWdX Z2dYdZ Z3dS )`r$ aI
|
Structured parse results, to provide multiple means of access to the parsed data:
|
- as a list (C{len(results)})
|
- by list index (C{results[0], results[1]}, etc.)
|
- by attribute (C{results.<resultsName>} - see L{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 C s" t || r|S t | ¡}d|_|S ©NT)r} ÚobjectÚ__new__Ú_ParseResults__doinit)r® ÚtoklistÚnameÚasListÚmodalÚretobjry ry rz r× k s
|
|
|
zParseResults.__new__c
|
C sb | j rvd| _ d | _d | _i | _|| _|| _|d kr6g }||trP|d d
| _n ||trft|| _n|g| _t | _
|
|d k r^|r^|sd| j|< ||t r¦t |}|| _||t d ttfrÐ|d dg fks^||trà|g}|r(||trt| ¡ d| |< ntt|d d| |< || | _n6z|d | |< W n$ tttfk
|
r\ || |< Y nX d S )NFr r )rØ Ú_ParseResults__nameÚ_ParseResults__parentÚ_ParseResults__accumNamesÚ_ParseResults__asListÚ_ParseResults__modalÚlistÚ_ParseResults__toklistÚ_generatorTypeÚdictÚ_ParseResults__tokdictrv r rÁ Ú
|
basestringr$ rÊ ÚcopyÚKeyErrorÚ TypeErrorÚ
|
IndexError)r« rÙ rÚ rÛ rÜ r} ry ry rz r t sB
|
|
|
|
$
|
zParseResults.__init__c C sP t |ttfr| j| S || jkr4| j| d d S tdd | j| D S d S )Nrt r c S s g | ] }|d qS ©r ry ©r Úvry ry rz Ú
|
<listcomp>¢ s z,ParseResults.__getitem__.<locals>.<listcomp>)r} rv Úslicerä rà rç r$ rÏ ry ry rz rÑ s
|
|
|
zParseResults.__getitem__c C s ||t r0| j |t ¡|g | j|< |d }nD||ttfrN|| j|< |}n&| j |t ¡t |dg | j|< |}||trt| |_ d S rÒ )
|
rÊ rç Úgetrã rv rñ rä r$ Úwkrefrß )r« Úkrï r} Úsubry ry rz Ú __setitem__¤ s
|
|
|
"
|
zParseResults.__setitem__c
|
C sº t |ttfr®t| j}| j|= t |trH|dk r:||7 }t||d }tt| |¡ }| ¡ | j
|
¡ D ]>\}}|D ]0}t |D ]"\}\}} t || | |k ||< qqxqln| j |= d S ©Nr r ) r} rv rñ Úlenrä rã ÚrangeÚindicesÚreverserç ÚitemsÚ enumeraterÊ )
|
r« rÐ ÚmylenÚremovedrÚ Ú occurrencesÚjrô ÚvalueÚpositionry ry rz Ú __delitem__± s
|
|
zParseResults.__delitem__c C s
|
|| j kS r )rç )r« rô ry ry rz Ú __contains__Æ s zParseResults.__contains__c C s
|
t | jS r )rø rä rµ ry ry rz Ú__len__É r| zParseResults.__len__c C s
|
| j S r ©rä rµ ry ry rz Ú__bool__Ê r| zParseResults.__bool__c C s
|
t | jS r ©Úiterrä rµ ry ry rz Ú__iter__Ì r| zParseResults.__iter__c C s t | jd d d
S ©Nrt r rµ ry ry rz Ú __reversed__Í r| zParseResults.__reversed__c C s$ t | jdr| j ¡ S t| jS d S )NÚiterkeys)Úhasattrrç r r
|
rµ ry ry rz Ú _iterkeysÎ s
|
zParseResults._iterkeysc s fdd ¡ D S )Nc 3 s | ]} | V qd S r ry ©r rô rµ ry rz r Õ s z+ParseResults._itervalues.<locals>.<genexpr>©r rµ ry rµ rz Ú _itervaluesÔ s zParseResults._itervaluesc s fdd ¡ D S )Nc 3 s | ]}| | fV qd S r ry r rµ ry rz r Ø s z*ParseResults._iteritems.<locals>.<genexpr>r rµ ry rµ rz Ú
|
_iteritems× s zParseResults._iteritemsc C s t | ¡ S )zVReturns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x).)rã r rµ ry ry rz Úkeysî s zParseResults.keysc C s t | ¡ S )zXReturns all named result values (as a list in Python 2.x, as an iterator in Python 3.x).)rã Ú
|
itervaluesrµ ry ry rz Úvaluesò s zParseResults.valuesc C s t | ¡ S )zfReturns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x).)rã Ú iteritemsrµ ry ry rz rü ö s zParseResults.itemsc C s
|
t | jS )zSince keys() returns an iterator, this method is helpful in bypassing
|
code that looks for the existence of any defined results names.)Úboolrç rµ ry ry rz Úhaskeysú s zParseResults.haskeysc O s |s
|
dg}| ¡ D ]*\}}|dkr0|d |f}qtd| qt|d tsdt|dksd|d | kr~|d }| | }| |= |S |d }|S dS )a¹
|
Removes and returns item at specified index (default=C{last}).
|
Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
|
argument or an integer argument, it will use C{list} semantics
|
and pop tokens from the list of parsed tokens. If passed a
|
non-integer argument (most likely a string), it will use C{dict}
|
semantics and pop the corresponding value from any defined
|
results names. A second default return value argument is
|
supported, just as in C{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']
|
rt Údefaultr z-pop() got an unexpected keyword argument '%s'r N)rü rë r} rv rø )r« rª Úkwargsrô rï Úindexr Ú defaultvaluery ry rz Úpopÿ s" "
|
ÿ
|
þzParseResults.popc C s || kr| | S |S dS )ai
|
Returns named result matching the given key, or if there is no
|
such name, then returns the given C{defaultValue} or C{None} if no
|
C{defaultValue} is specified.
|
|
Similar to C{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
|
Nry )r« ÚkeyÚ defaultValuery ry rz rò 3 s zParseResults.getc C sR | j ||¡ | j ¡ D ]4\}}t|D ]"\}\}}t||||k ||< q(qdS )a
|
Inserts new element at location index in the list of parsed tokens.
|
|
Similar to C{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)rä Úinsertrç rü rý rÊ )r« r ÚinsStrrÚ r rô r r ry ry rz r" I s zParseResults.insertc C s | 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)rä Úappend)r« Úitemry ry rz r$ ] s zParseResults.appendc C s$ t |tr| |7 } n | 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} r$ rä Úextend)r« Úitemseqry ry rz r& k s
|
|
zParseResults.extendc C s | j dd
= | j ¡ dS )z7
|
Clear all elements and results names.
|
N)rä rç Úclearrµ ry ry rz r( } s zParseResults.clearc C sj z
|
| | W S t k
|
r Y dS X || jkrb|| jkrH| j| d d S tdd | j| D S ndS d S )Nr rt r c S s g | ] }|d qS rí ry rî ry ry rz rð s z,ParseResults.__getattr__.<locals>.<listcomp>)rê rç rà r$ ©r« rÚ ry ry rz r´ s
|
|
|
zParseResults.__getattr__c C s | ¡ }||7 }|S r ©ré )r« Úotherr ry ry rz Ú__add__ s zParseResults.__add__c s |j rjt| jfdd |j ¡ } fdd|D }|D ],\}}|| |< t|d tr<t| |d _q<| j|j7 _| j |j¡ | S )Nc s | dk r S | S rÒ ry )Úa)Úoffsetry rz r{ r| z'ParseResults.__iadd__.<locals>.<lambda>c s4 g | ],\}}|D ] }|t |d |d fqqS ©r r )rÊ ©r rô Úvlistrï )Ú addoffsetry rz rð s ÿz)ParseResults.__iadd__.<locals>.<listcomp>r )
|
rç rø rä rü r} r$ ró rß rà Úupdate)r« r+ Ú
|
otheritemsÚotherdictitemsrô rï ry )r2 r. rz Ú__iadd__ s
|
|
|
ÿ zParseResults.__iadd__c C s& t |tr|dkr| ¡ S || S d S rÒ )r} rv ré ©r« r+ ry ry rz Ú__radd__§ s zParseResults.__radd__c C s dt | jt | jf S )Nz(%s, %s))rÓ rä rç rµ ry ry rz r¸ ¯ s zParseResults.__repr__c C s dd dd | jD ¡ d S )Nú[ú, c s s( | ] }t |trt|nt|V qd S r )r} r$ r rÓ ©r rÐ ry ry rz r ³ s z'ParseResults.__str__.<locals>.<genexpr>ú])rº rä rµ ry ry rz r¶ ² s zParseResults.__str__r c C sL g }| j D ]<}|r |r | |¡ t|tr8|| ¡ 7 }q
|
| t|¡ q
|
|S r )rä r$ r} r$ Ú _asStringListr )r« ÚsepÚoutr% ry ry rz r= µ s
|
|
|
zParseResults._asStringListc C s dd | j D S )a
|
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) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
|
|
# Use asList() to create an actual list
|
result_list = result.asList()
|
print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
|
c S s" g | ]}t |tr| ¡ n|qS ry )r} r$ rÛ )r Úresry ry rz rð Î s z'ParseResults.asList.<locals>.<listcomp>r rµ ry ry rz rÛ À s zParseResults.asListc s6 t r | j}n| j} fdd t fdd| 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)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
|
|
result_dict = result.asDict()
|
print(type(result_dict), repr(result_dict)) # -> <class '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 s6 t | tr.| ¡ r| ¡ S fdd| D S n| S d S )Nc s g | ] } |qS ry ry rî ©ÚtoItemry rz rð í s z7ParseResults.asDict.<locals>.toItem.<locals>.<listcomp>)r} r$ r ÚasDict)r rA ry rz rB è s
|
|
z#ParseResults.asDict.<locals>.toItemc 3 s | ]\}}| |fV qd S r ry ©r rô rï rA ry rz r ñ s z&ParseResults.asDict.<locals>.<genexpr>)ÚPY_3rü r ræ )r« Úitem_fnry rA rz rC Ð s
|
zParseResults.asDictc C s8 t | j}| j ¡ |_| j|_|j | j¡ | j|_|S )zA
|
Returns a new copy of a C{ParseResults} object.
|
)r$ rä rç ré rß rà r3 rÞ ©r« r ry ry rz ré ó s
|
zParseResults.copyFc C sL d}g }t dd | j ¡ D }|d }|s8d}d}d}d} |dk rJ|} n | jrV| j} | sf|rbdS d} |||d| d g7 }t| jD ]¬\}
|
} t| trà|
|
|krÀ|| ||
|
|o²|dk||¡g7 }n || d|oÒ|dk||¡g7 }qd} |
|
|krô||
|
} | s|rqnd} t t
|
| } |||d| d | d
|
| d g 7 }q|||d
|
| d g7 }d |¡S ) z
|
(Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
|
Ú
|
c s s( | ] \}}|D ]}|d |fV qqdS ©r Nry r0 ry ry rz r s ÿz%ParseResults.asXML.<locals>.<genexpr>ú r NÚITEMú<ú>ú</) ræ rç rü rÞ rý rä r} r$ ÚasXMLr r rº )r« ÚdoctagÚnamedItemsOnlyÚindentÚ formattedÚnlr? Ú
|
namedItemsÚnextLevelIndentÚselfTagrÐ r@ ÚresTagÚ xmlBodyTextry ry rz rO þ s^
|
|
ý
|
|
ý
|
þzParseResults.asXMLc C s: | j ¡ D ]*\}}|D ] \}}||kr| S qq
|
d S r )rç rü )r« rõ rô r1 rï r¦ ry ry rz Ú__lookup; s
|
zParseResults.__lookupc C s | j r | j S | jr.| ¡ }|r(| | ¡S dS nNt| dkrxt| jdkrxtt| j ¡ d d dkrxtt| j ¡ S dS dS )a(
|
Returns the results name for this token expression. Useful when several
|
different expressions might match at a particular location.
|
|
Example::
|
integer = Word(nums)
|
ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
|
house_number_expr = Suppress('#') + Word(nums, alphanums)
|
user_data = (Group(house_number_expr)("house_number")
|
| Group(ssn_expr)("ssn")
|
| Group(integer)("age"))
|
user_info = OneOrMore(user_data)
|
|
result = user_info.parseString("22 111-22-3333 #221B")
|
for item in result:
|
print(item.getName(), ':', item[0])
|
prints::
|
age : 22
|
ssn : 111-22-3333
|
house_number : 221B
|
Nr r )r rt ) rÞ rß Ú_ParseResults__lookuprø rç Únextr
|
r r )r« Úparry ry rz ÚgetNameB s
|
ÿ þzParseResults.getNamer c C sZ g }d}| |t| ¡ ¡ |rP| ¡ r¼tdd | ¡ D }|D ]r\}}|r\| |¡ | d|d| |f ¡ t|trª|r| | ||d ¡¡ q¸| t|¡ qF| t |¡ qFnt
|
dd | D rP| }t |D ]r\} }
|
t|
|
tr$| d|d| | |d|d |
|
||d ¡f ¡ qÜ| d|d| | |d|d t|
|
f ¡ qÜd |¡S )
|
aH
|
Diagnostic method for listing out the contents of a C{ParseResults}.
|
Accepts an optional C{indent} argument so that this string can be embedded
|
in a nested display of other data.
|
|
Example::
|
integer = Word(nums)
|
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
|
result = date_str.parseString('12/31/1999')
|
print(result.dump())
|
prints::
|
['12', '/', '31', '/', '1999']
|
- day: 1999
|
- month: 31
|
- year: 12
|
rH c s s | ]\}}t ||fV qd S r )r rD ry ry rz r ~ s z$ParseResults.dump.<locals>.<genexpr>z
|
%s%s- %s: rJ r c s s | ]}t |tV qd S r )r} r$ )r Úvvry ry rz r s z
|
%s%s[%d]:
|
%s%s%sr ) r$ r rÛ r Úsortedrü r} r$ ÚdumprÓ Úanyrý rº ) r« rR ÚdepthÚfullr? ÚNLrü rô rï rÐ r_ ry ry rz ra g s,
|
|
4,zParseResults.dumpc O s t j | ¡ f|| dS )aõ
|
Pretty-printer for parsed results as a list, using the C{pprint} module.
|
Accepts additional positional or keyword args as defined for the
|
C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#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)ÚpprintrÛ ©r« rª r ry ry rz rf s zParseResults.pprintc C s. | j | j ¡ | jd k r | ¡ p d | j| jffS r )rä rç ré rß rà rÞ rµ ry ry rz Ú __getstate__¬ s ýÿzParseResults.__getstate__c C sN |d | _ |d \| _}}| _i | _| j |¡ |d k rDt|| _nd | _d S r÷ )rä rç rÞ rà r3 ró rß )r« Ústater] Ú inAccumNamesry ry rz Ú __setstate__³ s
|
ý zParseResults.__setstate__c C s | j | j| j| jfS r )rä rÞ rá râ rµ ry ry rz Ú__getnewargs__À s zParseResults.__getnewargs__c C s t t| t| ¡ S r )rÀ rÁ rã r rµ ry ry rz r à s zParseResults.__dir__)NNTT)N)r )NFr T)r r T)4r r r rà r× r} r rÑ rö r r r r Ú __nonzero__r r r r r rE r r rü r r r r r rò r" r$ r& r( r´ r, r6 r8 r¸ r¶ r= rÛ rC ré rO r[ r^ ra rf rh rk rl r ry ry ry rz r$ D sh &
|
' 4
|
|
#
|
=%
|
- c C sF |}d| k r t |k r4n n|| d dkr4dS | | dd| ¡ 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 L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
|
on parsing strings containing C{<TAB>}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 rH )rø Úrfind)r¦ Ústrgr ry ry rz r; È s
|
c C s | dd| ¡d 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 L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
|
on parsing strings containing C{<TAB>}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.
|
rH r r )Úcount)r¦ ro ry ry rz rL Õ s
|
c C sF | dd| ¡}| d| ¡}|dkr2||d |
S ||d d
S dS )zfReturns the line of text containing loc within a string, counting newlines as line separators.
|
rH r r N)rn Úfind)r¦ ro ÚlastCRÚnextCRry ry rz rI á s
|
c C s8 t dt| d t| dt|| t|| f d S )NzMatch z at loc z(%d,%d))Úprintr rL r; )Úinstringr¦ Úexprry ry rz Ú_defaultStartDebugActionë s rw c C s$ t dt| d t| ¡ d S )NzMatched z -> )rt r r rÛ )ru ÚstartlocÚendlocrv Útoksry ry rz Ú_defaultSuccessDebugActionî s r{ c C s t dt| d S )NzException raised:)rt r )ru r¦ rv Úexcry ry rz Ú _defaultExceptionDebugActionñ s r} c G s dS )zG'Do-nothing' debug action, to suppress debugging output during parsing.Nry )rª ry ry rz rS ô s rs c sÒ t krfddS dgdgtd d
dkrFddd}dd d
|
n tj}tj d }|dd d }|d |d | f fdd}d}ztdtdj}W n tk
|
rÆ t}Y nX ||_|S )Nc s |S r ry ©r Úlrx )Úfuncry rz r{ r| z _trim_arity.<locals>.<lambda>r Frs )rq é c S s8 t dkr dnd}tj| | d d| }|d d
gS )N)rq r r éýÿÿÿéþÿÿÿr ©Úlimitrs )Úsystem_versionÚ tracebackÚ extract_stack)r
r. Ú frame_summaryry ry rz r s z"_trim_arity.<locals>.extract_stackc S s$ t j| |d}|d }|d d
gS )Nr rt rs )r Ú
|
extract_tb)Útbr
Úframesr ry ry rz r s z _trim_arity.<locals>.extract_tbé r rt r c s z"| d d
}dd< |W S t k
|
r d r> n4z.t ¡ d } |ddd d d
ksj W 5 ~X d krd d7 < Y q Y q X q d S )Nr Trt rs r r )rë r Úexc_info)rª r r ©r Ú
|
foundArityr r
ÚmaxargsÚpa_call_line_synthry rz Úwrapper- s z _trim_arity.<locals>.wrapperz<parse action>r Ú __class__)r )r ) ÚsingleArgBuiltinsr r r r Úgetattrr Ú Exceptionr )r r r Ú LINE_DIFFÚ this_liner Ú func_namery r rz Ú _trim_arity s,
|
|
ÿr c s e Zd ZdZdZdZedd Zedd Zddd Z d
|
d Z
|
d d Z dddZ dddZ dd Zdd Zdd Zdd Zdd Zd d Zdd d Zd!d" Zdd#d$Zd%d& Zd'd( ZG d)d* d*eZed+k ràG d,d- d-eZ nG d.d- d-eZ i Z e Z d/d/gZ dd0d1Z!eZ"ed2d3 Z#dZ$edd5d6Z%dd7d8Z&e'dfd9d:Z(d;d< Z)e'fd=d>Z*e'dfd?d@Z+dAdB Z,dCdD Z-dEdF Z.dGdH Z/dIdJ Z0dKdL Z1dMdN Z2dOdP Z3dQdR Z4dSdT Z5dUdV Z6dWdX Z7dYdZ Z8dd[d\Z9d]d^ Z:d_d` Z;dadb Z<dcdd Z=dedf Z>dgdh Z?ddidjZ@dkdl ZAdmdn ZBdodp ZCdqdr ZDg fdsdtZEddudvZF fdwdxZGdydz ZHd{d| ZId}d~ ZJdd ZKdddZLddd
ZM ZNS )r& z)Abstract base level parser element class.z
|
Fc C s
|
| t _dS )aÑ
|
Overrides the default whitespace chars
|
|
Example::
|
# default whitespace chars are space, <TAB> 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)r& ÚDEFAULT_WHITE_CHARS©Úcharsry ry rz ÚsetDefaultWhitespaceCharsT s z'ParserElement.setDefaultWhitespaceCharsc C s
|
| t _dS )a
|
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)r& Ú_literalStringClass)r® ry ry rz ÚinlineLiteralsUsingc s z!ParserElement.inlineLiteralsUsingc C s t | _d | _d | _d | _|| _d| _tj| _ d| _
|
d| _ d| _ t | _ d| _d| _d| _d| _d| _d| _d | _d| _d| _d S )NTFr )NNN)rã Ú parseActionÚ
|
failActionÚstrReprÚ resultsNameÚ
|
saveAsListÚskipWhitespacer& r Ú
|
whiteCharsÚcopyDefaultWhiteCharsÚmayReturnEmptyÚkeepTabsÚ ignoreExprsÚdebugÚ streamlinedÚ mayIndexErrorÚerrmsgÚ modalResultsÚ debugActionsÚreÚ callPreparseÚ callDuringTry)r« Úsavelistry ry rz r x s( zParserElement.__init__c C s< t | ¡}| jdd
|_| jdd
|_| jr8tj|_|S )a$
|
Make a copy of this C{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 C{expr.copy()} is just C{expr()}::
|
integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
|
N)ré r¢ r¬ r© r& r r¨ )r« Úcpyry ry rz ré s
|
zParserElement.copyc C s* || _ d| j | _t| dr&| j| j_| S )af
|
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 Ú exception)rÚ r° r r¹ r§ r) ry ry rz ÚsetName¦ s
|
|
|
zParserElement.setNamec C s4 | ¡ }| d¡r"|dd
}d}||_| |_|S )aP
|
Define name for referencing matching tokens as a nested attribute
|
of the returned parse results.
|
NOTE: this returns a *copy* of the original C{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,
|
C{expr("name")} in place of C{expr.setResultsName("name")} -
|
see L{I{__call__}<__call__>}.
|
|
Example::
|
date_str = (integer.setResultsName("year") + '/'
|
+ integer.setResultsName("month") + '/'
|
+ integer.setResultsName("day"))
|
|
# equivalent form:
|
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
Ú*Nrt T)ré Úendswithr¥ r± )r« rÚ ÚlistAllMatchesÚnewselfry ry rz ÚsetResultsName´ s
|
z ParserElement.setResultsNameTc s@ |r&| j d fdd } |_|| _ nt| j dr<| j j| _ | S )z¦Method to invoke the Python pdb debugger when this element is
|
about to be parsed. Set C{breakFlag} to True to enable, False to
|
disable.
|
Tc s dd l }| ¡ | |||S rÒ )ÚpdbÚ set_trace)ru r¦ Ú doActionsÚ callPreParserÀ ©Ú _parseMethodry rz Úbreaker× s z'ParserElement.setBreak.<locals>.breakerÚ_originalParseMethod)TT)Ú_parserÇ r )r« Ú breakFlagrÆ ry rÄ rz ÚsetBreakÐ s
|
zParserElement.setBreakc O s& t ttt || _| 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 C{fn(s,loc,toks)},
|
C{fn(loc,toks)}, C{fn(toks)}, or just C{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 C{L{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.
|
|
Optional keyword arguments:
|
- callDuringTry = (default=C{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 L{I{parseString}<parseString>} for more information
|
on parsing strings containing C{<TAB>}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]
|
rµ F)rã Úmapr r¢ rò rµ ©r« Úfnsr ry ry rz r â s "z ParserElement.setParseActionc O s4 | j tttt|7 _ | jp,| dd¡| _| S )z³
|
Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.
|
|
See examples in L{I{copy}<copy>}.
|
rµ F)r¢ rã rË r rµ rò rÌ ry ry rz ÚaddParseAction s z ParserElement.addParseActionc s^ | dd¡| dd¡r tnt |D ] fdd}| j |¡ q$| jpV| dd¡| _| S )aÓ Add a boolean predicate function to expression's list of parse actions. See
|
L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction},
|
functions passed to C{addCondition} need to return boolean success/fail of the condition.
|
|
Optional keyword arguments:
|
- message = define a custom message to be used in the raised exception
|
- fatal = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
|
|
Example::
|
integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
|
year_int = integer.copy()
|
year_int.addCondition(lambda toks: toks[0] >= 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)
|
Úmessagez failed user-defined conditionÚfatalFc s$ t t| ||s | |d S r )r r r~ ©Úexc_typeÚfnr§ ry rz Úpa& s z&ParserElement.addCondition.<locals>.parµ )rò r# r! r¢ r$ rµ )r« rÍ r rÔ ry rÑ rz Ú addCondition s zParserElement.addConditionc C s
|
|| _ | S )a Define action to perform if parsing fails at this expression.
|
Fail acton fn is a callable function that takes the arguments
|
C{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 C{L{ParseFatalException}}
|
if it is desired to stop parsing immediately.)r£ )r« rÓ ry ry rz Ú setFailAction- s
|
zParserElement.setFailActionc C sN d}|rJd}| j D ]4}z| ||¡\}}d}qW q tk
|
rD Y qX qq|S ©NTF)r¬ rÈ r! )r« ru r¦ Ú
|
exprsFoundÚeÚdummyry ry rz Ú_skipIgnorables: s
|
|
|
z ParserElement._skipIgnorablesc C sH | j r| ||¡}| jrD| j}t|}||k rD|| |krD|d7 }q&|S ©Nr )r¬ rÛ r§ r¨ rø )r« ru r¦ ÚwtÚinstrlenry ry rz ÚpreParseG s
|
zParserElement.preParsec C s |g fS r ry ©r« ru r¦ r ry ry rz Ú parseImplS s zParserElement.parseImplc C s |S r ry ©r« ru r¦ Ú tokenlistry ry rz Ú postParseV s zParserElement.postParsec
|
C sÎ | j }|s| jrì| jd r,| jd ||| |rD| jrD| ||¡}n|}|}zDz| |||¡\}}W n( tk
|
r t|t|| j | Y nX W nX t
|
k
|
rè } z:| jd rÀ| jd ||| | | jrÖ| ||| | ¡ W 5 d } ~ X Y nX n|r| jr| ||¡}n|}|}| j s&|t|krjz| |||¡\}}W n* tk
|
rf t|t|| j | Y nX n| |||¡\}}| |||¡}t || j| j| jd}
|
| jr|s¶| jr|rTzN| jD ]B} | |||
|
}|d k rÄt || j| joút|t tf| jd}
|
qÄW nF t
|
k
|
rP } z&| jd r>| jd ||| | W 5 d } ~ X Y nX nJ| jD ]B} | |||
|
}|d k rZt || j| jot|t tf| jd}
|
qZ|rÆ| jd rÆ| jd |||| |
|
||
|
fS )Nr rs )rÛ rÜ r )r r£ r² r´ rß rá rì r! rø r° r r¯ rä r$ r¥ r¦ r± r¢ rµ r} rã ) r« ru r¦ r rÃ Ú debuggingÚprelocÚ tokensStartÚtokensÚerrÚ retTokensrÓ ry ry rz Ú _parseNoCacheZ st
|
|
|
|
|
|
ý
|
|
ý
|
zParserElement._parseNoCachec C s@ z| j ||ddd W S tk
|
r: t||| j| Y nX d S )NF)r r )rÈ r# r! r° ©r« ru r¦ ry ry rz ÚtryParse¡ s zParserElement.tryParsec C s4 z| ||¡ W n ttfk
|
r* Y dS X dS d S )NFT)rí r! rì rì ry ry rz Ú canParseNext§ s
|
zParserElement.canParseNextc @ s e Zd Zdd ZdS )z ParserElement._UnboundedCachec s~ i t | _ fdd} fdd} fdd} fdd}t || ¡| _t || ¡| _t || ¡| _t || ¡| _d S ) Nc s |¡S r ©rò ©r« r ©ÚcacheÚ not_in_cachery rz rò ´ s z3ParserElement._UnboundedCache.__init__.<locals>.getc s | |< d S r ry ©r« r r ©rò ry rz Úset· s z3ParserElement._UnboundedCache.__init__.<locals>.setc s ¡ d S r ©r( rµ rõ ry rz r( º s z5ParserElement._UnboundedCache.__init__.<locals>.clearc s t S r ©rø rµ rõ ry rz Ú cache_len½ s z9ParserElement._UnboundedCache.__init__.<locals>.cache_len)rÖ ró ÚtypesÚ
|
MethodTyperò rö r( r )r« rò rö r( rù ry rñ rz r ° s z&ParserElement._UnboundedCache.__init__N©r r r r ry ry ry rz Ú_UnboundedCache¯ s rý Nc @ s e Zd Zdd ZdS )úParserElement._FifoCachec s t | _t fdd} fdd} fdd} fdd}t || ¡| _t || ¡| _t || ¡| _t || ¡| _d S ) Nc s |¡S r rï rð rñ ry rz rò Ì s ú.ParserElement._FifoCache.__init__.<locals>.getc s> | |< t kr:z d¡ W q tk
|
r6 Y qX qd S ©NF)rø Úpopitemrê rô )rò Úsizery rz rö Ï s ú.ParserElement._FifoCache.__init__.<locals>.setc s ¡ d S r r÷ rµ rõ ry rz r( × s ú0ParserElement._FifoCache.__init__.<locals>.clearc s t S r rø rµ rõ ry rz rù Ú s ú4ParserElement._FifoCache.__init__.<locals>.cache_len) rÖ ró Ú _OrderedDictrú rû rò rö r( r ©r« r rò rö r( rù ry )rò ró r rz r Ç s ú!ParserElement._FifoCache.__init__Nrü ry ry ry rz Ú
|
_FifoCacheÆ s r c @ s e Zd Zdd ZdS )rþ c s t | _i t g ¡ fdd} fdd} fdd} fdd}t || ¡| _t || ¡| _t || ¡| _t || ¡| _ d S ) Nc s |¡S r rï rð rñ ry rz rò ê s rÿ c s4 | |< t kr& ¡ d ¡ q |¡ d S r )rø r Úpopleftr$ rô )rò Úkey_fifor ry rz rö í s r c s ¡ ¡ d S r r÷ rµ )rò r ry rz r( ó s r c s t S r rø rµ rõ ry rz rù ÷ s r )
|
rÖ ró Ú collectionsÚdequerú rû rò rö r( r r ry )rò r ró r rz r ä s r Nrü ry ry ry rz r ã s r c C s d\}}| ||||f}t jî t j}| |¡} | |jkrÆt j| d7 < z| ||||¡} W n8 tk
|
r }
|
z| ||
|
j |
|
j
|
¡ W 5 d }
|
~
|
X Y n.X | || d | d ¡ f¡ | W 5 Q R £ S n@t j| d7 < t | t ræ| | d | d ¡ fW 5 Q R £ S W 5 Q R X d S )Nr/ r r )r& Úpackrat_cache_lockÚ packrat_cacherò ró Úpackrat_cache_statsrë r rö r rª ré r} r ) r« ru r¦ r rà ÚHITÚMISSÚlookuprò r r¯ ry ry rz Ú _parseCache s$
|
|
|
zParserElement._parseCachec C s( t j ¡ dgtt j t jd d
< d S rÒ )r& r r( rø r ry ry ry rz Ú
|
resetCache s
|
zParserElement.resetCacheé c C s8 t js4dt _| dkr t ¡ t _n t | ¡t _t jt _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=C{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 C{ParserElement.enablePackrat()}. If
|
your program uses C{psyco} to "compile as you go", you must call
|
C{enablePackrat} before calling C{psyco.full()}. If you do not do this,
|
Python will crash. For best results, call C{enablePackrat()} immediately
|
after importing pyparsing.
|
|
Example::
|
import pyparsing
|
pyparsing.ParserElement.enablePackrat()
|
TN)r& Ú_packratEnabledrý r r r rÈ )Úcache_size_limitry ry rz Ú enablePackrat% s zParserElement.enablePackratc
|
C s® t ¡ | js| ¡ | jD ] }| ¡ q | js8| ¡ }z<| |d¡\}}|rr| ||¡}t t
|
}| ||¡ W n0 t k
|
r¤ } zt j r n|W 5 d}~X Y nX |S dS )aB
|
Execute the parse expression with the given string.
|
This is the main interface to the client code, once the complete
|
expression has been built.
|
|
If you want the grammar to require that the entire input string be
|
successfully parsed, then set C{parseAll} to True (equivalent to ending
|
the grammar with C{L{StringEnd()}}).
|
|
Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
|
in order to report proper column numbers in parse actions.
|
If the input string contains tabs and
|
the grammar uses parse actions that use the C{loc} argument to index into the
|
string being parsed, you can ensure you have a consistent view of the input
|
string by:
|
- calling C{parseWithTabs} on your grammar before calling C{parseString}
|
(see L{I{parseWithTabs}<parseWithTabs>})
|
- define your parse action using the full C{(s,loc,toks)} signature, and
|
reference the input string using the parse action's C{s} argument
|
- explictly expand the tabs in your input string before calling
|
C{parseString}
|
|
Example::
|
Word('a').parseString('aaaaabaaa') # -> ['aaaaa']
|
Word('a').parseString('aaaaabaaa', parseAll=True) # -> Exception: Expected end of text
|
r N) r& r r® Ú
|
streamliner¬ r« Ú
|
expandtabsrÈ rß r r+ r Úverbose_stacktrace)r« ru ÚparseAllrÙ r¦ rè Úser| ry ry rz Ú parseStringH s$
|
|
zParserElement.parseStringc
|
c s6 | j s| ¡ | jD ] }| ¡ q| js4t| ¡ }t|}d}| j}| j}t
|
¡ d} z¤||krú| |k rúz |||}
|
|||
|
dd\} } W n t k
|
r¦ |
|
d }Y qZX | |krð| d7 } | |
|
| fV |rê|||} | |krà| }qî|d7 }qø| }qZ|
|
d }qZW n4 t k
|
r0 } zt j r n|W 5 d}~X Y nX dS )a
|
Scan the input string for expression matches. Each match will return the
|
matching tokens, start location, and end location. May be called with optional
|
C{maxMatches} argument, to clip scanning after 'n' matches are found. If
|
C{overlap} is specified, then overlapping matches will be reported.
|
|
Note that the start and end locations are reported relative to the string
|
being parsed. See L{I{parseString}<parseString>} for more information on parsing
|
strings with embedded tabs.
|
|
Example::
|
source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
|
print(source)
|
for tokens,start,end in Word(alphas).scanString(source):
|
print(' '*start + '^'*(end-start))
|
print(' '*start + tokens[0])
|
|
prints::
|
|
sldjf123lsdjjkf345sldkjf879lkjsfd987
|
^^^^^
|
sldjf
|
^^^^^^^
|
lsdjjkf
|
^^^^^^
|
sldkjf
|
^^^^^^
|
lkjsfd
|
r F©rà r N)r® r r¬ r« r r rø rß rÈ r& r r! r r )r« ru Ú
|
maxMatchesÚoverlaprÙ rÞ r¦ Ú
|
preparseFnÚparseFnÚmatchesræ ÚnextLocrè Únextlocr| ry ry rz Ú
|
scanStringz sB
|
|
|
|
|
zParserElement.scanStringc
|
C sà g }d}d| _ z| |¡D ]Z\}}}| |||
¡ |rpt|trR|| ¡ 7 }n t|trf||7 }n
|
| |¡ |}q| ||d
¡ dd |D }d tt t
|
|¡W S t k
|
rÚ } zt j rÆ n|W 5 d}~X Y nX dS )af
|
Extension to C{L{scanString}}, to modify matching text with modified tokens that may
|
be returned from a parse action. To use C{transformString}, define a grammar and
|
attach a parse action to it that modifies the returned token list.
|
Invoking C{transformString()} on a target string will then scan for matches,
|
and replace the matched text patterns according to the logic in the parse
|
action. C{transformString()} returns the resulting transformed string.
|
|
Example::
|
wd = Word(alphas)
|
wd.setParseAction(lambda toks: toks[0].title())
|
|
print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
|
Prints::
|
Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
|
r TNc S s g | ] }|r|qS ry ry )r Úory ry rz rð ã s z1ParserElement.transformString.<locals>.<listcomp>r )r« r( r$ r} r$ rÛ rã rº rË r Ú_flattenr r& r )r« ru r? ÚlastErx r rÙ r| ry ry rz r
Á s(
|
|
|
|
z ParserElement.transformStringc
|
C sR z t dd | ||¡D W S tk
|
rL } ztjr8 n|W 5 d}~X Y nX dS )a
|
Another extension to C{L{scanString}}, simplifying the access to the tokens found
|
to match the given parse expression. May be called with optional
|
C{maxMatches} argument, to clip searching after 'n' matches are found.
|
|
Example::
|
# a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
|
cap_word = Word(alphas.upper(), alphas.lower())
|
|
print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))
|
|
# the sum() builtin can be used to merge results into a single ParseResults object
|
print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
|
prints::
|
[['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
|
['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
|
c S s g | ]\}}}|qS ry ry )r rx r rÙ ry ry rz rð ÿ s z.ParserElement.searchString.<locals>.<listcomp>N)r$ r( r r& r )r« ru r! r| ry ry rz Ú searchStringì s zParserElement.searchStringc c sT d}d}| j ||dD ]*\}}}|||
V |r<|d V |}q||d
V dS )a[
|
Generator method to split a string using the given expression as a separator.
|
May be called with optional C{maxsplit} argument, to limit the number of splits;
|
and the optional C{includeSeparators} argument (default=C{False}), if the separating
|
matching text should be included in the split results.
|
|
Example::
|
punc = oneOf(list(".,;:/-!?"))
|
print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
|
prints::
|
['This', ' this', '', ' this sentence', ' is badly punctuated', '']
|
r )r! N)r( ) r« ru ÚmaxsplitÚincludeSeparatorsÚsplitsÚlastrx r rÙ ry ry rz r s
|
zParserElement.splitc C sF t |trt |¡}t |ts:tjdt| tdd dS t| |gS )a
|
Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
|
converts them to L{Literal}s by default.
|
|
Example::
|
greet = Word(alphas) + "," + Word(alphas) + "!"
|
hello = "Hello, World!"
|
print (hello, "->", greet.parseString(hello))
|
Prints::
|
Hello, World! -> ['Hello', ',', 'World', '!']
|
ú4Cannot combine element of type %s with ParserElementrs ©Ú
|
stacklevelN) r} rè r& r ÚwarningsÚwarnrÁ Ú SyntaxWarningr r7 ry ry rz r, s
|
|
|
ÿzParserElement.__add__c C sB t |trt |¡}t |ts:tjdt| tdd dS || S )z]
|
Implementation of + operator when left operand is not a C{L{ParserElement}}
|
r1 rs r2 N©r} rè r& r r4 r5 rÁ r6 r7 ry ry rz r8 1 s
|
|
|
ÿzParserElement.__radd__c C sJ t |trt |¡}t |ts:tjdt| tdd dS | t ¡ | S )zQ
|
Implementation of - operator, returns C{L{And}} with error stop
|
r1 rs r2 N)
|
r} rè r& r r4 r5 rÁ r6 r Ú
|
_ErrorStopr7 ry ry rz Ú__sub__= s
|
|
|
ÿzParserElement.__sub__c C sB t |trt |¡}t |ts:tjdt| tdd dS || S )z]
|
Implementation of - operator when left operand is not a C{L{ParserElement}}
|
r1 rs r2 Nr7 r7 ry ry rz Ú__rsub__I s
|
|
|
ÿzParserElement.__rsub__c s¸ t |tr|d }}nät |trì|d dd
}|d dkrHd|d f}t |d tr |d dkr |d dkrvtS |d dkrtS |d t S qút |d trÎt |d trÎ|\}}||8 }qútdt|d t|d ntdt||dk r td|dk r td || kr6dkrBn ntd
|
|r fd d |r|dkrt | }ntg| | }n |}n |dkr¦}ntg| }|S ) aå
|
Implementation of * operator, allows use of C{expr * 3} in place of
|
C{expr + expr + expr}. Expressions may also me multiplied by a 2-integer
|
tuple, similar to C{{min,max}} multipliers in regular expressions. Tuples
|
may also include C{None} as in:
|
- C{expr*(n,None)} or C{expr*(n,)} is equivalent
|
to C{expr*n + L{ZeroOrMore}(expr)}
|
(read as "at least n instances of C{expr}")
|
- C{expr*(None,n)} is equivalent to C{expr*(0,n)}
|
(read as "0 to n instances of C{expr}")
|
- C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
|
- C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
|
|
Note that C{expr*(None,n)} does not raise an exception if
|
more than n exprs exist in the input stream; that is,
|
C{expr*(None,n)} does not enforce a maximum number of expr
|
occurrences. If this behavior is desired, then write
|
C{expr*(None,n) + ~expr}
|
r )NNNrs r z7cannot 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 s( | dkr t | d S t S d S rÜ )r ©Ún©ÚmakeOptionalListr« ry rz r> s z/ParserElement.__mul__.<locals>.makeOptionalList) r} rv Útupler4 r rë rÁ Ú
|
ValueErrorr )r« r+ Ú minElementsÚ optElementsr ry r= rz Ú__mul__U sD
|
|
|
|
|
|
|
|
zParserElement.__mul__c C s
|
| |¡S r )rC r7 ry ry rz Ú__rmul__ s zParserElement.__rmul__c C sF t |trt |¡}t |ts:tjdt| tdd dS t| |gS )zI
|
Implementation of | operator - returns C{L{MatchFirst}}
|
r1 rs r2 N) r} rè r& r r4 r5 rÁ r6 r r7 ry ry rz Ú__or__ s
|
|
|
ÿzParserElement.__or__c C sB t |trt |¡}t |ts:tjdt| tdd dS || B S )z]
|
Implementation of | operator when left operand is not a C{L{ParserElement}}
|
r1 rs r2 Nr7 r7 ry ry rz Ú__ror__¨ s
|
|
|
ÿzParserElement.__ror__c C sF t |trt |¡}t |ts:tjdt| tdd dS t| |gS )zA
|
Implementation of ^ operator - returns C{L{Or}}
|
r1 rs r2 N) r} rè r& r r4 r5 rÁ r6 r r7 ry ry rz Ú__xor__´ s
|
|
|
ÿzParserElement.__xor__c C sB t |trt |¡}t |ts:tjdt| tdd dS || A S )z]
|
Implementation of ^ operator when left operand is not a C{L{ParserElement}}
|
r1 rs r2 Nr7 r7 ry ry rz Ú__rxor__À s
|
|
|
ÿzParserElement.__rxor__c C sF t |trt |¡}t |ts:tjdt| tdd dS t| |gS )zC
|
Implementation of & operator - returns C{L{Each}}
|
r1 rs r2 N) r} rè r& r r4 r5 rÁ r6 r r7 ry ry rz Ú__and__Ì s
|
|
|
ÿzParserElement.__and__c C sB t |trt |¡}t |ts:tjdt| tdd dS || @ S )z]
|
Implementation of & operator when left operand is not a C{L{ParserElement}}
|
r1 rs r2 Nr7 r7 ry ry rz Ú__rand__Ø s
|
|
|
ÿzParserElement.__rand__c C s t | S )zE
|
Implementation of ~ operator - returns C{L{NotAny}}
|
)r rµ ry ry rz Ú
|
__invert__ä s zParserElement.__invert__c C s |dk r| |¡S | ¡ S dS )a
|
Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
|
|
If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
|
passed as C{True}.
|
|
If C{name} is omitted, same as calling C{L{copy}}.
|
|
Example::
|
# these are equivalent
|
userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
|
userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")
|
N)r¿ ré r) ry ry rz Ú__call__ê s
|
zParserElement.__call__c C s t | S )z
|
Suppresses the output of this C{ParserElement}; useful to keep punctuation from
|
cluttering up returned output.
|
)r- rµ ry ry rz Úsuppressý s zParserElement.suppressc C s
|
d| _ | S )a
|
Disables the skipping of whitespace before matching the characters in the
|
C{ParserElement}'s defined pattern. This is normally only used internally by
|
the pyparsing module, but may be needed in some whitespace-sensitive grammars.
|
F©r§ rµ ry ry rz ÚleaveWhitespace s z ParserElement.leaveWhitespacec C s d| _ || _d| _| S )z8
|
Overrides the default whitespace chars
|
TF)r§ r¨ r© )r« r ry ry rz ÚsetWhitespaceChars s z ParserElement.setWhitespaceCharsc C s
|
d| _ | S )zé
|
Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.
|
Must be called before C{parseString} when the input grammar contains elements that
|
match C{<TAB>} characters.
|
T)r« rµ ry ry rz Ú parseWithTabs s zParserElement.parseWithTabsc C sL t |trt|}t |tr4|| jkrH| j |¡ n| 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} rè r- r¬ r$ ré r7 ry ry rz Úignore s
|
|
|
zParserElement.ignorec C s" |pt |p t|ptf| _d| _| S )zT
|
Enable display of debugging messages while doing pattern matching.
|
T)rw r{ r} r² r )r« Ú startActionÚ successActionÚexceptionActionry ry rz ÚsetDebugActions6 s þz ParserElement.setDebugActionsc C s |r| ttt¡ nd| _| S )a
|
Enable display of debugging messages while doing pattern matching.
|
Set C{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 L{setDebugActions}. Prior to attempting
|
to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}
|
is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
|
message is shown. Also note the use of L{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 C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
|
F)rV rw r{ r} r )r« Úflagry ry rz ÚsetDebug@ s #zParserElement.setDebugc C s | j S r )rÚ rµ ry ry rz r¶ i s zParserElement.__str__c C s t | S r r· rµ ry ry rz r¸ l s zParserElement.__repr__c C s d| _ d | _| S rÕ )r® r¤ rµ ry ry rz r o s zParserElement.streamlinec C s d S r ry rÈ ry ry rz ÚcheckRecursiont s z ParserElement.checkRecursionc C s | g ¡ dS )zj
|
Check defined expressions for valid structure, check for infinite recursive definitions.
|
N)rY )r« Ú validateTracery ry rz Úvalidatew s zParserElement.validatec C s z | ¡ }W n2 tk
|
r> t|d}| ¡ }W 5 Q R X Y nX z| ||¡W S tk
|
r~ } ztjrj n|W 5 d}~X Y nX dS )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.
|
ÚrN)Úreadr² Úopenr r r& r )r« Úfile_or_filenamer Ú file_contentsÚfr| ry ry rz Ú parseFile} s zParserElement.parseFilec sH t |tr"| |kp t| t|kS t |tr6| |¡S tt| |kS d S r )r} r& Úvarsrè r% Úsuperr7 ©r ry rz Ú__eq__ s
|
|
|
|
zParserElement.__eq__c C s
|
| |k S r ry r7 ry ry rz Ú__ne__ s zParserElement.__ne__c C s t t| S r )ÚhashÚidrµ ry ry rz Ú__hash__ s zParserElement.__hash__c C s | |kS r ry r7 ry ry rz Ú__req__ s zParserElement.__req__c C s
|
| |k S r ry r7 ry ry rz Ú__rne__¢ s zParserElement.__rne__c C s4 z| j t||d W dS tk
|
r. Y dS X dS )aÓ
|
Method for quick testing of a parser against a test string. Good for simple
|
inline microtests of sub expressions while building up larger parser.
|
|
Parameters:
|
- testString - to test against this expression for a match
|
- parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
|
|
Example::
|
expr = Word(nums)
|
assert expr.matches("100")
|
©r TFN)r r r )r« Ú
|
testStringr ry ry rz r% ¥ s
|
zParserElement.matchesú#c C sò t |tr"tttj| ¡ ¡ }t |tr4t|}g }g }d} |D ]¢}
|
|dk r^| |
|
d¡sf|rr|
|
sr|
|
|
|
¡ qD|
|
sxqDd |¡|
|
g} g }z:|
|
dd¡}
|
| j |
|
|d} |
|
| j|d¡ | oÀ| } W nð tk
|
rr } zt | trædnd }d|
|
kr*|
|
t| j|
|
¡ |
|
d
|
t| j|
|
d d | ¡ n|
|
d
|
| j d | ¡ |
|
d t| ¡ | o\|} | } W 5 d} ~ X Y nD tk
|
r´ } z$|
|
dt| ¡ | o|} |} W 5 d}~X Y nX |rÚ|rÌ|
|
d ¡ td | ¡ |
|
|
|
| f¡ qD| |fS )a3
|
Execute the parse expression on a series of test strings, showing each
|
test, the parsed results or where the parse failed. Quick and easy way to
|
run a parse expression against a list of sample strings.
|
|
Parameters:
|
- tests - a list of separate test strings, or a multiline string of test strings
|
- parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
|
- comment - (default=C{'#'}) - expression for indicating embedded comments in the test
|
string; pass None to disable comment filtering
|
- fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
|
if False, only dump nested list
|
- printResults - (default=C{True}) prints test output to stdout
|
- failureTests - (default=C{False}) indicates if these tests are expected to fail parsing
|
|
Returns: a (success, results) tuple, where success indicates that all tests succeeded
|
(or failed if C{failureTests} is True), and the results contain a list of lines of each
|
test's output
|
|
Example::
|
number_expr = pyparsing_common.number.copy()
|
|
result = number_expr.runTests('''
|
# unsigned integer
|
100
|
# negative integer
|
-100
|
# float with scientific notation
|
6.02e23
|
# integer with scientific notation
|
1e-12
|
''')
|
print("Success" if result[0] else "Failed!")
|
|
result = number_expr.runTests('''
|
# stray character
|
100Z
|
# missing leading digit before '.'
|
-.100
|
# too many '.'
|
3.14.159
|
''', failureTests=True)
|
print("Success" if result[0] else "Failed!")
|
prints::
|
# unsigned integer
|
100
|
[100]
|
|
# negative integer
|
-100
|
[-100]
|
|
# float with scientific notation
|
6.02e23
|
[6.02e+23]
|
|
# integer with scientific notation
|
1e-12
|
[1e-12]
|
|
Success
|
|
# stray character
|
100Z
|
^
|
FAIL: Expected end of text (at char 3), (line:1, col:4)
|
|
# missing leading digit before '.'
|
-.100
|
^
|
FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
|
|
# too many '.'
|
3.14.159
|
^
|
FAIL: Expected end of text (at char 4), (line:1, col:5)
|
|
Success
|
|
Each test string must be on a single line. If you want to test a string that spans multiple
|
lines, create a test like this::
|
|
expr.runTest(r"this is a test\n of strings that spans \n 3 lines")
|
|
(Note that this is a raw string literal, you must include the leading 'r'.)
|
TNFrH ú\nrm )rd z(FATAL)r ú r ú^zFAIL: zFAIL-EXCEPTION: )r} rè rã rË r r» ÚrstripÚ
|
splitlinesr r% r$ rº r r ra r r# rI r¦ r; r rt )r« Útestsr ÚcommentÚfullDumpÚ printResultsÚ failureTestsÚ
|
allResultsÚcommentsÚsuccessrx r? Úresultr¯ rÐ r| ry ry rz ÚrunTests¸ sN W
|
|
|
|
|
$
|
|
|
zParserElement.runTests)F)F)T)T)TT)TT)r )F)N)T)F)T)Tro TTF)Or r r rà r r Ú staticmethodr r¡ r ré rº r¿ rÊ r rÎ rÕ rÖ rÛ rß rá rä rë rí rî rÖ rý r r r r r r r rÈ r r r r Ú_MAX_INTr( r
r, r r, r8 r9 r: rC rD rE rF rG rH rI rJ rK rL rM rO rP rQ rR rV rX r¶ r¸ r rY r[ rb rf rg rj rk rl r% r~ Ú __classcell__ry ry re rz r& O s
|
|
|
|
|
&
|
|
|
G
|
|
"
|
2G+ D
|
|
|
)
|
|
c s e Zd ZdZ fddZ ZS )r. zT
|
Abstract C{ParserElement} subclass, for defining atomic matching patterns.
|
c s t t| jdd d S ©NF©r¶ )rd r. r rµ re ry rz r @ s zToken.__init__©r r r rà r r ry ry re rz r. < s c s e Zd ZdZ fddZ ZS )r z,
|
An empty token, will always match.
|
c s$ t t| ¡ d| _d| _d| _d S )Nr TF)rd r r rÚ rª r¯ rµ re ry rz r H s zEmpty.__init__r ry ry re rz r D s c s* e Zd ZdZ fddZdddZ ZS )r z(
|
A token that will never match.
|
c s* t t| ¡ d| _d| _d| _d| _d S )Nr TFzUnmatchable token)rd r r rÚ rª r¯ r° rµ re ry rz r S s
|
zNoMatch.__init__Tc C s t ||| j| d S r )r! r° rà ry ry rz rá Z s zNoMatch.parseImpl)T©r r r rà r rá r ry ry re rz r O s c s* e Zd ZdZ fddZdddZ ZS )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 L{CaselessLiteral}.
|
|
For keyword matching (force word break before and after the matched string),
|
use L{Keyword} or L{CaselessKeyword}.
|
c s t t| ¡ || _t|| _z|d | _W n* tk
|
rV tj dt
|
dd t | _ Y nX dt | j | _d| j | _d| _d| _d S )Nr z2null string passed to Literal; use Empty() insteadrs r2 ú"%s"r¸ F)rd r r Úmatchrø ÚmatchLenÚfirstMatchCharrì r4 r5 r6 r r r rÚ r° rª r¯ ©r« Ú matchStringre ry rz r l s
|
ÿ zLiteral.__init__Tc C sJ || | j kr6| jdks&| | j|¡r6|| j | jfS t||| j| d S rÜ )r r Ú
|
startswithr r! r° rà ry ry rz rá s ÿ ÿzLiteral.parseImpl)Tr
ry ry re rz r ^ s c sL e Zd ZdZed Zd fdd Zddd Z fd
|
d Ze d d Z
|
Z S )r 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 C{L{Literal}}:
|
- C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
|
- C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
|
Accepts two optional constructor arguments in addition to the keyword string:
|
- C{identChars} is a string of characters that would be valid identifier characters,
|
defaulting to all alphanumerics + "_" and "$"
|
- C{caseless} allows case-insensitive matching, default is C{False}.
|
|
Example::
|
Keyword("start").parseString("start") # -> ['start']
|
Keyword("start").parseString("starting") # -> Exception
|
|
For case-insensitive matching, use L{CaselessKeyword}.
|
ú_$NFc s® t t| ¡ |d kr tj}|| _t|| _z|d | _W n$ tk
|
r^ t j
|
dt dd Y nX d| j | _ d| j | _ d| _d| _|| _|r | ¡ | _| ¡ }t|| _d S )Nr z2null string passed to Keyword; use Empty() insteadrs r2 r r¸ F)rd r r ÚDEFAULT_KEYWORD_CHARSr rø r r rì r4 r5 r6 rÚ r° rª r¯ ÚcaselessÚupperÚ caselessmatchrö Ú
|
identChars)r« r r r re ry rz r s*
|
ÿ
|
zKeyword.__init__Tc C s | j r||||| j
¡ | jkrò|t|| j ksL||| j ¡ | jkrò|dksj||d ¡ | jkrò|| j | jfS nv|| | jkrò| jdks¢| | j|¡rò|t|| j ksÈ||| j | jkrò|dksâ||d | jkrò|| j | jfS t ||| j
|
| d S r÷ ) r r r r rø r r r r r! r° rà ry ry rz rá ¯ s4 ÿÿþþÿ ÿþþýýzKeyword.parseImplc s t t| ¡ }tj|_|S r )rd r ré r r )r« r¤ re ry rz ré ½ s z Keyword.copyc C s
|
| t _dS )z,Overrides the default Keyword chars
|
N)r r r ry ry rz ÚsetDefaultKeywordChars s z Keyword.setDefaultKeywordChars)NF)T) r r r rà r5 r r rá ré r r r ry ry re rz r s
|
c s* e Zd ZdZ fddZdddZ ZS )r
|
al
|
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 L{CaselessKeyword}.)
|
c s6 t t| | ¡ ¡ || _d| j | _d| j | _d S )Nz'%s'r¸ )rd r
|
r r Ú returnStringrÚ r° r re ry rz r Ó s zCaselessLiteral.__init__Tc C s@ |||| j
¡ | jkr,|| j | jfS t||| j| d S r )r r r r r! r° rà ry ry rz rá Ú s zCaselessLiteral.parseImpl)Tr
ry ry re rz r
|
È s
|
c s, e Zd ZdZd fdd Zd ddZ ZS )
|
r zÐ
|
Caseless version of L{Keyword}.
|
|
Example::
|
OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
|
|
(Contrast with example for L{CaselessLiteral}.)
|
Nc s t t| j||dd d S )NT©r )rd r r )r« r r re ry rz r è s zCaselessKeyword.__init__Tc C sj |||| j
¡ | jkrV|t|| j ksF||| j ¡ | jkrV|| j | jfS t||| j| d S r )r r r rø r r r! r° rà ry ry rz rá ë s ÿÿzCaselessKeyword.parseImpl)N)Tr
ry ry re rz r ß s c s, e Zd ZdZd fdd Zd ddZ ZS )
|
rn ax
|
A variation on L{Literal} which matches "close" matches, that is,
|
strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
|
- C{match_string} - string to be matched
|
- C{maxMismatches} - (C{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:
|
- C{mismatches} - a list of the positions within the match_string where mismatches were found
|
- C{original} - the original match_string used to compare against the input string
|
|
If C{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 sB t t| ¡ || _|| _|| _d| j| jf | _d| _d| _d S )Nz&Expected %r (with up to %d mismatches)F) rd rn r rÚ Ú match_stringÚ maxMismatchesr° r¯ rª )r« r r re ry rz r
|
|
s zCloseMatch.__init__Tc C sÊ |}t |}|t | j }||kr¶| j}d}g } | j}
|
tt|||
| jD ]2\}} | \} } | | krN| |¡ t | |
|
krN q¶qN|d }t|||
g}| j|d< | |d< ||fS t||| j| d S )Nr r ÚoriginalÚ
|
mismatches) rø r r rý r r$ r$ r! r° )r« ru r¦ r ÚstartrÞ Úmaxlocr Úmatch_stringlocr r Ús_mÚsrcÚmatÚresultsry ry rz rá
|
s(
|
|
zCloseMatch.parseImpl)r )Tr
ry ry re rz rn ñ s c s8 e Zd ZdZd fdd Zdd d
|
Z fd d Z ZS )r1 a
|
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 C{min} is 1 (a
|
minimum value < 1 is not valid); the default values for C{max} and C{exact}
|
are 0, meaning no maximum or exact length restriction. An optional
|
C{excludeChars} parameter can list characters that might be found in
|
the input C{bodyChars} string; useful to define a word of all printables
|
except for one or two characters, for instance.
|
|
L{srange} is useful for defining custom character set strings for defining
|
C{Word} expressions, using range notation from regular expression character sets.
|
|
A common mistake is to use C{Word} to match a specific literal string, as in
|
C{Word("Address")}. Remember that C{Word} uses the string argument to define
|
I{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 L{Literal} or L{Keyword}.
|
|
pyparsing includes helper strings for building Words:
|
- L{alphas}
|
- L{nums}
|
- L{alphanums}
|
- L{hexnums}
|
- L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
|
- L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
|
- L{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 sÌ t t| ¡ rFd fdd|D ¡}|rFd fdd|D ¡}|| _t|| _|rl|| _t|| _n|| _t|| _|dk| _ |dk rt
|
d|| _ |dkr¬|| _ nt | _ |dkrÆ|| _ || _ t| | _d| j | _d | _|| _d
|
| j| j krÈ|dkrÈ|dkrÈ|dkrÈ| j| jkr8d t| j | _nHt| jdkrfd t | j¡t| jf | _nd t| jt| jf | _| jrd| j d | _zt | j¡| _W n tk
|
rÆ d | _Y nX d S )Nr c 3 s | ]}| kr|V qd S r ry r£ ©Ú excludeCharsry rz r `
|
s z Word.__init__.<locals>.<genexpr>c 3 s | ]}| kr|V qd S r ry r£ r¡ ry rz r b
|
s r r zZcannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permittedr¸ Frq z[%s]+z%s[%s]*z [%s][%s]*z\b)rd r1 r rº Ú initCharsOrigrö Ú initCharsÚ bodyCharsOrigÚ bodyCharsÚ maxSpecifiedr@ ÚminLenÚmaxLenr r rÚ r° r¯ Ú asKeywordÚ_escapeRegexRangeCharsÚreStringrø r³ ÚescapeÚcompiler )r« r¤ r¦ ÚminÚmaxÚexactrª r¢ re r¡ rz r ]
|
s\
|
|
|
|
0
|
ÿÿÿÿz Word.__init__Tc
|
C s> | j r<| j ||¡}|s(t||| j| | ¡ }|| ¡ fS || | jkrZt||| j| |}|d7 }t|}| j}|| j }t
|
||}||k r¦|| |kr¦|d7 }qd} || | j k r¼d} | j rÚ||k rÚ|| |krÚd} | j r|dkrü||d |ks||k r|| |krd} | r.t||| j| ||||
fS )Nr FTr )r³ r r! r° ÚendÚgroupr¤ rø r¦ r© r¯ r¨ r§ rª )
|
r« ru r¦ r r} r rÞ Ú bodycharsr ÚthrowExceptionry ry rz rá
|
s6
|
|
|
2zWord.parseImplc sv zt t| ¡ W S tk
|
r$ Y nX | jd krpdd }| j| jkr`d|| j|| jf | _nd|| j | _| jS )Nc S s$ t | dkr | d d
d S | S d S )Né ú...rø ©r ry ry rz Ú
|
charsAsStr¿
|
s z Word.__str__.<locals>.charsAsStrz W:(%s,%s)zW:(%s))rd r1 r¶ r r¤ r£ r¥ )r« r¹ re ry rz r¶ ¶
|
s
|
z Word.__str__)Nr r r FN)T©r r r rà r rá r¶ r ry ry re rz r1 .
|
s .6
|
#c sF e Zd ZdZee d¡Zd fdd Zd ddZ fd d
|
Z
|
Z S ) r) a
|
Token for matching strings that match a given regular expression.
|
Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
|
If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as
|
named parse results.
|
|
Example::
|
realnum = Regex(r"[+-]?\d+\.\d*")
|
date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
|
# ref: http://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?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
|
z[A-Z]r c sÞ t t| ¡ t|tr|s,tjdtdd || _|| _ z t
|
| j| j ¡| _
|
| j| _ W q¸ t jk
|
r tjd| tdd Y q¸X n2t|tjr°|| _
|
t| | _| _ || _ ntdt| | _d| j | _d| _d| _d S )
|
zThe parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags.z0null string passed to Regex; use Empty() insteadrs r2 ú$invalid pattern (%s) passed to RegexzCRegex may only be constructed with a string or a compiled RE objectr¸ FTN)rd r) r r} rè r4 r5 r6 ÚpatternÚflagsr³ r® r¬ Ú sre_constantsÚerrorÚcompiledREtyper r@ r rÚ r° r¯ rª )r« r¼ r½ re ry rz r Û
|
s:
|
ÿ
|
ÿ
|
ÿ
|
zRegex.__init__Tc C s` | j ||¡}|s"t||| j| | ¡ }| ¡ }t| ¡ }|rX|D ]}|| ||< qF||fS r )r³ r r! r° r² Ú groupdictr$ r³ )r« ru r¦ r r} Údr rô ry ry rz rá ý
|
s zRegex.parseImplc sF zt t| ¡ W S tk
|
r$ Y nX | jd kr@dt| j | _| jS )NzRe:(%s))rd r) r¶ r r¤ rÓ r¼ rµ re ry rz r¶
|
s
|
z Regex.__str__)r )T) r r r rà rÁ r³ r® rÀ r rá r¶ r ry ry re rz r) Í
|
s
|
"
|
c s8 e Zd ZdZd fdd Zd ddZ fd d
|
Z ZS ) r' 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=C{None})
|
- escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
|
- multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
|
- unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
|
- endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
|
- convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{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
|
sN t t ¡ | ¡ }|s0tjdtdd t |d kr>|}n"| ¡ }|s`tjdtdd t | _t | _
|
|d _ | _ t | _ | _| _| _| _|rètjtjB _dt j¡t j d |d k rÜt|pÞdf _n<d _dt j¡t j d |d k rt|p df _t j d krp jd
|
d fd d tt j d ddD ¡ d 7 _|r jdt |¡ 7 _|r¾ jdt |¡ 7 _t j¡d _ jdt j ¡ 7 _z t j j¡ _ j _ W n0 t j k
|
r& tjd j tdd Y nX t _!d j! _"d _#d _$d S )Nz$quoteChar cannot be the empty stringrs r2 z'endQuoteChar cannot be the empty stringr z %s(?:[^%s%s]r z%s(?:[^%s\n\r%s]r z|(?:z)|(?:c 3 s4 | ],}d t jd|
¡t j| f V qdS )z%s[^%s]N)r³ r Ú endQuoteCharr« r; rµ ry rz r X s þ ÿz(QuotedString.__init__.<locals>.<genexpr>rt ú)z|(?:%s)z|(?:%s.)z(.)z)*%sr» r¸ FT)%rd r' r r» r4 r5 r6 Ú SyntaxErrorÚ quoteCharrø Ú quoteCharLenÚfirstQuoteCharrà ÚendQuoteCharLenÚescCharÚescQuoteÚunquoteResultsÚconvertWhitespaceEscapesr³ Ú MULTILINEÚDOTALLr½ r r« r¼ rº rù ÚescCharReplacePatternr® r¬ r¾ r¿ r rÚ r° r¯ rª )r« rÆ rÊ rË Ú multilinerÌ rà rÍ re rµ rz r / s|
|
|
|
|
þÿ
|
þÿþþÿ ÿ
|
zQuotedString.__init__c C sÔ || | j kr | j ||¡p d }|s4t||| j| | ¡ }| ¡ }| jrÌ|| j| j
}t
|
|t rÌd|kr | j r ddddd}| ¡ D ]\}}| ||¡}q| jr¶t | jd|¡}| jrÌ| | j| j¡}||fS )Nú\ú rH ú ú )ú\trp z\fz\rz\g<1>)rÈ r³ r r! r° r² r³ rÌ rÇ rÉ r} rè rÍ rü r rÊ rõ rÐ rË rà ) r« ru r¦ r r} r Úws_mapÚwslitÚwscharry ry rz rá p s*
|
üzQuotedString.parseImplc sH zt t| ¡ W S tk
|
r$ Y nX | jd krBd| j| jf | _| jS )Nz.quoted string, starting with %s ending with %s)rd r' r¶ r r¤ rÆ rà rµ re ry rz r¶ s
|
zQuotedString.__str__)NNFTNT)Trº ry ry re rz r' s A
|
#c s8 e Zd ZdZd fdd Zd ddZ fd d
|
Z ZS ) r aô
|
Token for matching words composed of characters I{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 C{min} is 1 (a
|
minimum value < 1 is not valid); the default values for C{max} and C{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 s t t| ¡ d| _|| _|dk r*td|| _|dkr@|| _nt| _|dkrZ|| _|| _t | | _
|
d| j
|
| _ | jdk| _ d| _ d S )NFr zfcannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permittedr r¸ )rd r r r§ ÚnotCharsr@ r¨ r© r r rÚ r° rª r¯ )r« rÚ r¯ r° r± re ry rz r ¯ s
|
zCharsNotIn.__init__Tc C s || | j kr t||| j| |}|d7 }| j }t|| j t|}||k rb|| |krb|d7 }qD|| | jk rt||| j| ||||
fS rÜ )rÚ r! r° r¯ r© rø r¨ )r« ru r¦ r r ÚnotcharsÚmaxlenry ry rz rá Ç s
|
ÿ
|
zCharsNotIn.parseImplc sf zt t| ¡ W S tk
|
r$ Y nX | jd kr`t| jdkrTd| jd d
| _n d| j | _| jS )Nr¶ z
|
!W:(%s...)z!W:(%s))rd r r¶ r r¤ rø rÚ rµ re ry rz r¶ Ø s
|
zCharsNotIn.__str__)r r r )Trº ry ry re rz r s
|
c s< e Zd ZdZddddddZd fd d ZdddZ ZS )r0 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 C{" \t\r\n"}. Also takes optional C{min}, C{max}, and C{exact} arguments,
|
as defined for the C{L{Word}} class.
|
z<SPC>z<TAB>z<LF>z<CR>z<FF>)rq rÓ rH rÕ rÔ ú
|
r r c s t t ¡ | _ d fdd jD ¡¡ d dd jD ¡ _d _d j _ | _
|
|dkrt| _ nt _ |dkr| _ | _
|
d S )Nr c 3 s | ]}| j kr|V qd S r )Ú
|
matchWhiter£ rµ ry rz r ø s
|
z!White.__init__.<locals>.<genexpr>c s s | ]}t j| V qd S r )r0 Ú whiteStrsr£ ry ry rz r ú s Tr¸ r ) rd r0 r rÞ rP rº r¨ rÚ rª r° r¨ r© r )r« Úwsr¯ r° r± re rµ rz r õ s zWhite.__init__Tc C s || | j kr t||| j| |}|d7 }|| j }t|t|}||k rb|| | j krb|d7 }qB|| | jk rt||| j| ||||
fS rÜ )rÞ r! r° r© r¯ rø r¨ )r« ru r¦ r r r ry ry rz rá s
|
|
zWhite.parseImpl)rÝ r r r )T)r r r rà rß r rá r ry ry re rz r0 æ s ûc s e Zd Z fddZ ZS )Ú_PositionTokenc s( t t| ¡ | jj| _d| _d| _d S r× )rd rá r r r rÚ rª r¯ rµ re ry rz r s
|
z_PositionToken.__init__©r r r r r ry ry re rz rá s rá c s2 e Zd ZdZ fddZdd Zd ddZ ZS )
|
r zb
|
Token to advance to a specific column of input text; useful for tabular report scraping.
|
c s t t| ¡ || _d S r )rd r r r; )r« Úcolnore ry rz r $ s zGoToColumn.__init__c C s\ t ||| j krXt|}| jr*| ||¡}||k rX|| ¡ rXt ||| j krX|d7 }q*|S rÜ )r; rø r¬ rÛ Úisspace)r« ru r¦ rÞ ry ry rz rß ( s $
|
zGoToColumn.preParseTc C sD t ||}|| j kr"t||d| || j | }|||
}||fS )NzText not in expected column©r; r! )r« ru r¦ r ÚthiscolÚnewlocr ry ry rz rá 1 s
|
|
zGoToColumn.parseImpl)T)r r r rà r rß rá r ry ry re rz r s c s* e Zd ZdZ fddZdddZ ZS )r 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 s t t| ¡ d| _d S )NzExpected start of line)rd r r r° rµ re ry rz r O s zLineStart.__init__Tc C s* t ||dkr|g fS t||| j| d S rÜ )r; r! r° rà ry ry rz rá S s zLineStart.parseImpl)Tr
ry ry re rz r : s c s* e Zd ZdZ fddZdddZ ZS )r zU
|
Matches if current position is at the end of a line within the parse string
|
c s, t t| ¡ | tj dd¡¡ d| _d S )NrH r zExpected end of line)rd r r rP r& r r r° rµ re ry rz r \ s zLineEnd.__init__Tc C sb |t |k r6|| dkr$|d dfS t||| j| n(|t |krN|d g fS t||| j| d S )NrH r ©rø r! r° rà ry ry rz rá a s zLineEnd.parseImpl)Tr
ry ry re rz r X s c s* e Zd ZdZ fddZdddZ ZS )r, zM
|
Matches if current position is at the beginning of the parse string
|
c s t t| ¡ d| _d S )NzExpected start of text)rd r, r r° rµ re ry rz r p s zStringStart.__init__Tc C s0 |dkr(|| |d¡kr(t||| j| |g fS rÒ )rß r! r° rà ry ry rz rá t s zStringStart.parseImpl)Tr
ry ry re rz r, l s c s* e Zd ZdZ fddZdddZ ZS )r+ zG
|
Matches if current position is at the end of the parse string
|
c s t t| ¡ d| _d S )NzExpected end of text)rd r+ r r° rµ re ry rz r s zStringEnd.__init__Tc C s^ |t |k r t||| j| n<|t |kr6|d g fS |t |krJ|g fS t||| j| d S rÜ rè rà ry ry rz rá s zStringEnd.parseImpl)Tr
ry ry re rz r+ { s c s. e Zd ZdZef fdd ZdddZ ZS )r3 ap
|
Matches if the current position is at the beginning of a Word, and
|
is not preceded by any character in a given set of C{wordChars}
|
(default=C{printables}). To emulate the C{} behavior of regular expressions,
|
use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
|
the string being parsed, or at the beginning of a line.
|
c s" t t| ¡ t|| _d| _d S )NzNot at the start of a word)rd r3 r rö Ú wordCharsr° ©r« ré re ry rz r s
|
zWordStart.__init__Tc C s@ |dkr8||d | j ks(|| | j kr8t||| j| |g fS r÷ )ré r! r° rà ry ry rz rá s ÿzWordStart.parseImpl)T©r r r rà rX r rá r ry ry re rz r3 s c s. e Zd ZdZef fdd ZdddZ ZS )r2 aZ
|
Matches if the current position is at the end of a Word, and
|
is not followed by any character in a given set of C{wordChars}
|
(default=C{printables}). To emulate the C{} behavior of regular expressions,
|
use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
|
the string being parsed, or at the end of a line.
|
c s( t t| ¡ t|| _d| _d| _d S )NFzNot at the end of a word)rd r2 r rö ré r§ r° rê re ry rz r © s
|
zWordEnd.__init__Tc C sP t |}|dkrH||k rH|| | jks8||d | jkrHt||| j| |g fS r÷ )rø ré r! r° )r« ru r¦ r rÞ ry ry rz rá ¯ s ÿzWordEnd.parseImpl)Trë ry ry re rz r2 ¡ s c s e Zd ZdZd fdd Zdd Zdd Zd d
|
Z fd d Z fd dZ fddZ
|
d fdd Z g fddZ fddZ ZS )r" z^
|
Abstract subclass of ParserElement, for combining and post-processing parsed tokens.
|
Fc s® t t| |¡ t|tr"t|}t|tr<t |¡g| _ nht|t
|
rxt|}t dd |D rlt tj|}t|| _ n,zt|| _ W n t k
|
r¢ |g| _ Y nX d| _d S )Nc s s | ]}t |tV qd S r )r} rè )r rv ry ry rz r Æ s z+ParseExpression.__init__.<locals>.<genexpr>F)rd r" r r} rå rã rè r& r Úexprsr ÚallrË rë r´ ©r« rì r¶ re ry rz r ¼ s
|
|
|
zParseExpression.__init__c C s
|
| j | S r )rì rÏ ry ry rz rÑ Ð s zParseExpression.__getitem__c C s | j |¡ d | _| S r )rì r$ r¤ r7 ry ry rz r$ Ó s zParseExpression.appendc C s0 d| _ dd | jD | _| jD ] }| ¡ q | S )z~Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on
|
all contained expressions.Fc S s g | ] }| ¡ qS ry r* ©r rÙ ry ry rz rð Ü s z3ParseExpression.leaveWhitespace.<locals>.<listcomp>)r§ rì rO )r« rÙ ry ry rz rO Ø s
|
|
|
z ParseExpression.leaveWhitespacec sr t |trB|| jkrntt| |¡ | jD ]}| | jd ¡ q*n,tt| |¡ | jD ]}| | jd ¡ qX| S r )r} r- r¬ rd r" rR rì )r« r+ rÙ re ry rz rR á s
|
|
|
|
zParseExpression.ignorec sN zt t| ¡ W S tk
|
r$ Y nX | jd krHd| jjt| jf | _| jS ©Nz%s:(%s)) rd r" r¶ r r¤ r r r rì rµ re ry rz r¶ í s
|
zParseExpression.__str__c s* t t| ¡ | jD ] }| ¡ qt| jdkr| jd }t|| jr |js |jd kr |j s |jd d
| jd g | _d | _
|
| j |j O _ | j |j O _ | jd }t|| jr|js|jd kr|j s| jd d
|jd d
| _d | _
|
| j |j O _ | j |j O _ dt | | _| S )Nrs r r rt r¸ )rd r" r rì rø r} r r¢ r¥ r r¤ rª r¯ r r° )r« rÙ r+ re ry rz r ÷ s<
|
|
|
ÿþý
|
ÿþý zParseExpression.streamlinec s t t| ||¡}|S r )rd r" r¿ )r« rÚ r½ r re ry rz r¿ s z ParseExpression.setResultsNamec C s6 |d d
| g }| j D ]}| |¡ q| g ¡ d S r )rì r[ rY )r« rZ ÚtmprÙ ry ry rz r[ s
|
zParseExpression.validatec s$ t t| ¡ }dd | jD |_|S )Nc S s g | ] }| ¡ qS ry r* rï ry ry rz rð % s z(ParseExpression.copy.<locals>.<listcomp>)rd r" ré rì rG re ry rz ré # s zParseExpression.copy)F)F)r r r rà r rÑ r$ rO rR r¶ r r¿ r[ ré r ry ry re rz r" ¸ s
|
" c sT e Zd ZdZG dd deZd fdd ZdddZd d
|
Zd d Z d d Z
|
Z S )r a
|
Requires all given C{ParseExpression}s to be found in the given order.
|
Expressions may be separated by whitespace.
|
May be constructed using the C{'+'} operator.
|
May also be constructed using the C{'-'} 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 s e Zd Z fddZ ZS )zAnd._ErrorStopc s& t tj| j|| d| _| ¡ d S )Nú-)rd r r8 r rÚ rO rg re ry rz r 9 s zAnd._ErrorStop.__init__râ ry ry re rz r8 8 s r8 Tc sR t t| ||¡ tdd | jD | _| | jd j¡ | jd j| _d| _ d S )Nc s s | ] }|j V qd S r ©rª rï ry ry rz r @ s z And.__init__.<locals>.<genexpr>r T)
|
rd r r rí rì rª rP r¨ r§ r´ rî re ry rz r > s
|
z And.__init__c C sþ | j d j|||dd\}}d}| j dd
D ]Æ}t|tjrDd}q.|rÎz| |||¡\}}W qà tk
|
rt Y qà tk
|
r¤ } zd |_t |¡W 5 d }~X Y qà t k
|
rÊ t|t
|
|| j | Y qàX n| |||¡\}}|sì| ¡ r.||7 }q.||fS )Nr Fr r T) rì rÈ r} r r8 r% r Ú __traceback__r° rì rø r° r ) r« ru r¦ r Ú
|
resultlistÚ errorStoprÙ Ú
|
exprtokensr¯ ry ry rz rá E s(
|
z And.parseImplc C s t |trt |¡}| |¡S r ©r} rè r& r r$ r7 ry ry rz r6 ^ s
|
|
z And.__iadd__c C s6 |d d
| g }| j D ]}| |¡ |js q2qd S r )rì rY rª ©r« rÉ ÚsubRecCheckListrÙ ry ry rz rY c s
|
|
|
zAnd.checkRecursionc C s@ t | dr| jS | jd kr:dd dd | jD ¡ d | _| jS )NrÚ Ú{rq c s s | ]}t |V qd S r r· rï ry ry rz r o s z And.__str__.<locals>.<genexpr>Ú}©r rÚ r¤ rº rì rµ ry ry rz r¶ j s
|
|
|
z And.__str__)T)T) r r r rà r r8 r rá r6 rY r¶ r ry ry re rz r ( s
|
c sD e Zd ZdZd fdd ZdddZdd Zd
|
d Zd d Z Z S )r a¾
|
Requires that at least one C{ParseExpression} is found.
|
If two expressions match, the expression that matches the longest string will be used.
|
May be constructed using the C{'^'} 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 s: t t| ||¡ | jr0tdd | jD | _nd| _d S )Nc s s | ] }|j V qd S r ró rï ry ry rz r
s z Or.__init__.<locals>.<genexpr>T)rd r r rì rb rª rî re ry rz r s z Or.__init__Tc C sR d}d }g }| j D ]}z| ||¡}W nv tk
|
rb } z d | _| j|krR| }| j}W 5 d } ~ X Y q tk
|
r t||krt|t||j| }t|}Y qX | ||f¡ q|r(|j dd d |D ]^\}
|
}z|
|
|||¡W S tk
|
r$ } z d | _| j|kr| }| j}W 5 d } ~ X Y qÈX qÈ|d k r@| j|_ |nt||d| d S )Nrt c S s
|
| d S rÒ ry )Úxry ry rz r{ r| z Or.parseImpl.<locals>.<lambda>)r ú no defined alternatives to match) rì rí r! rô r¦ rì rø r° r$ ÚsortrÈ r§ ) r« ru r¦ rÂ Ú maxExcLocÚ maxExceptionr% rÙ Úloc2ré Ú_ry ry rz rá s<
|
|
|
z Or.parseImplc C s t |trt |¡}| |¡S r rø r7 ry ry rz Ú__ixor__¯ s
|
|
z Or.__ixor__c C s@ t | dr| jS | jd kr:dd dd | jD ¡ d | _| jS )NrÚ rû z ^ c s s | ]}t |V qd S r r· rï ry ry rz r ¹ s z Or.__str__.<locals>.<genexpr>rü rý rµ ry ry rz r¶ ´ s
|
|
|
z
|
Or.__str__c C s, |d d
| g }| j D ]}| |¡ qd S r ©rì rY rù ry ry rz rY ½ s
|
zOr.checkRecursion)F)T)
|
r r r rà r rá r r¶ rY r ry ry re rz r t s
|
& c sD e Zd ZdZd fdd ZdddZdd Zd
|
d Zd d Z Z S )r a½
|
Requires that at least one C{ParseExpression} is found.
|
If two expressions match, the first one listed is the one that will match.
|
May be constructed using the C{'|'} 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 s: t t| ||¡ | jr0tdd | jD | _nd| _d S )Nc s s | ] }|j V qd S r ró rï ry ry rz r × s z&MatchFirst.__init__.<locals>.<genexpr>T)rd r r rì rb rª rî re ry rz r Ô s zMatchFirst.__init__Tc C sÆ d}d }| j D ]}z| |||¡}|W S tk
|
r` } z|j|krP|}|j}W 5 d }~X Y q tk
|
r t||krt|t||j| }t|}Y qX q|d k r´| j|_|nt||d| d S )Nrt rÿ )rì rÈ r! r¦ rì rø r° r§ ) r« ru r¦ r r r rÙ r ré ry ry rz rá Û s$
|
|
|
zMatchFirst.parseImplc C s t |trt |¡}| |¡S r rø r7 ry ry rz Ú__ior__ó s
|
|
zMatchFirst.__ior__c C s@ t | dr| jS | jd kr:dd dd | jD ¡ d | _| jS )NrÚ rû ú | c s s | ]}t |V qd S r r· rï ry ry rz r ý s z%MatchFirst.__str__.<locals>.<genexpr>rü rý rµ ry ry rz r¶ ø s
|
|
|
zMatchFirst.__str__c C s, |d d
| g }| j D ]}| |¡ qd S r r rù ry ry rz rY s
|
zMatchFirst.checkRecursion)F)T)
|
r r r rà r rá r r¶ rY r ry ry re rz r à s
|
c s< e Zd ZdZd fdd Zd ddZdd Zd d
|
Z ZS ) r am
|
Requires all given C{ParseExpression}s to be found, but in any order.
|
Expressions may be separated by whitespace.
|
May be constructed using the C{'&'} 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 s8 t t| ||¡ tdd | jD | _d| _d| _d S )Nc s s | ] }|j V qd S r ró rï ry ry rz r ? s z Each.__init__.<locals>.<genexpr>T)rd r r rí rì rª r§ ÚinitExprGroupsrî re ry rz r = s z Each.__init__c sî | j rtdd | jD | _dd | jD }dd | jD }|| | _dd | jD | _dd | jD | _dd | jD | _| j| j7 _d | _ |}| jd d
}| jd d
g }d
|
} | rj| | j | j }
|
g } |
|
D ]v} z| ||¡}W n t k
|
r |
|
| ¡ Y qÜX |
|
| j t | | ¡¡ | |kr@| | ¡ qÜ| krÜ | ¡ qÜt| t|
|
krºd } qº|rd d d |D ¡} t ||d | | fdd| jD 7 }g }|D ]"} | |||¡\}}|
|
|¡ q´t|tg }||fS )Nc s s& | ] }t |trt|j|fV qd S r )r} r ri rv rï ry ry rz r E s
|
z!Each.parseImpl.<locals>.<genexpr>c S s g | ]}t |tr|jqS ry ©r} r rv rï ry ry rz rð F s
|
z"Each.parseImpl.<locals>.<listcomp>c S s g | ]}|j rt|ts|qS ry )rª r} r rï ry ry rz rð G s
|
c S s g | ]}t |tr|jqS ry )r} r4 rv rï ry ry rz rð I s
|
c S s g | ]}t |tr|jqS ry )r} r rv rï ry ry rz rð J s
|
c S s g | ]}t |tttfs|qS ry )r} r r4 r rï ry ry rz rð K s FTr: c s s | ]}t |V qd S r r· rï ry ry rz r f s z*Missing one or more required elements (%s)c s$ g | ] }t |tr|j kr|qS ry r
|
rï ©ÚtmpOptry rz rð j s
|
|
)r ræ rì Úopt1mapÚ optionalsÚmultioptionalsÚ multirequiredÚrequiredrí r! r$ rò ri Úremoverø rº rÈ Úsumr$ )r« ru r¦ r Úopt1Úopt2ÚtmpLocÚtmpReqdÚ
|
matchOrderÚ keepMatchingÚtmpExprsÚfailedrÙ Úmissingrõ r Ú finalResultsry r rz rá C sP
|
|
zEach.parseImplc C s@ t | dr| jS | jd kr:dd dd | jD ¡ d | _| jS )NrÚ rû z & c s s | ]}t |V qd S r r· rï ry ry rz r y s z Each.__str__.<locals>.<genexpr>rü rý rµ ry ry rz r¶ t s
|
|
|
z Each.__str__c C s, |d d
| g }| j D ]}| |¡ qd S r r rù ry ry rz rY } s
|
zEach.checkRecursion)T)T) r r r rà r rá r¶ rY r ry ry re rz r s
|
5
|
1 c sl e Zd ZdZd fdd ZdddZdd Z fd
|
d Z fd d Zdd Z g fddZ
|
fddZ Z S )r za
|
Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
|
Fc s t t| |¡ t|tr@ttjtr2t |¡}nt t |¡}|| _
|
d | _ |d k r|j | _ |j | _ | |j¡ |j| _|j| _|j| _| j |j¡ d S r )rd r r r} rè Ú
|
issubclassr& r r. r rv r¤ r¯ rª rP r¨ r§ r¦ r´ r¬ r& ©r« rv r¶ re ry rz r s
|
z ParseElementEnhance.__init__Tc C s2 | j d k r | j j|||ddS td|| j| d S )NFr r )rv rÈ r! r° rà ry ry rz rá s
|
z ParseElementEnhance.parseImplc C s* d| _ | j ¡ | _| jd k r&| j ¡ | S r )r§ rv ré rO rµ ry ry rz rO s
|
|
|
z#ParseElementEnhance.leaveWhitespacec sr t |trB|| jkrntt| |¡ | jd k rn| j | jd ¡ n,tt| |¡ | jd k rn| j | jd ¡ | S r )r} r- r¬ rd r rR rv r7 re ry rz rR ¦ s
|
|
|
|
zParseElementEnhance.ignorec s& t t| ¡ | jd k r"| j ¡ | S r )rd r r rv rµ re ry rz r ² s
|
|
z ParseElementEnhance.streamlinec C sB | |krt || g |d d
| g }| jd k r>| j |¡ d S r )r( rv rY )r« rÉ rú ry ry rz rY ¸ s
|
|
z"ParseElementEnhance.checkRecursionc C s6 |d d
| g }| j d k r(| j |¡ | g ¡ d S r ©rv r[ rY ©r« rZ rñ ry ry rz r[ ¿ s
|
z ParseElementEnhance.validatec sX zt t| ¡ W S tk
|
r$ Y nX | jd krR| jd k rRd| jjt| jf | _| jS rð ) rd r r¶ r r¤ rv r r r rµ re ry rz r¶ Å s zParseElementEnhance.__str__)F)T) r r r rà r rá rO rR r rY r[ r¶ r ry ry re rz r s
|
c s* e Zd ZdZ fddZdddZ ZS )r aõ
|
Lookahead matching of the given parse expression. C{FollowedBy}
|
does I{not} advance the parsing position within the input string, it only
|
verifies that the specified parse expression matches at the current
|
position. C{FollowedBy} always returns a null token list.
|
|
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 s t t| |¡ d| _d S rÕ )rd r r rª ©r« rv re ry rz r á s zFollowedBy.__init__Tc C s | j ||¡ |g fS r )rv rí rà ry ry rz rá å s zFollowedBy.parseImpl)Tr
ry ry re rz r Ð s c s2 e Zd ZdZ fddZd ddZdd Z ZS )
|
r a±
|
Lookahead to disallow matching with the given parse expression. C{NotAny}
|
does I{not} advance the parsing position within the input string, it only
|
verifies that the specified parse expression does I{not} match at the current
|
position. Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
|
always returns a null token list. May be constructed using the '~' operator.
|
|
Example::
|
|
c s0 t t| |¡ d| _d| _dt| j | _d S )NFTzFound unwanted token, )rd r r r§ rª r rv r° r" re ry rz r õ s zNotAny.__init__Tc C s& | j ||¡r t||| j| |g fS r )rv rî r! r° rà ry ry rz rá ü s zNotAny.parseImplc C s4 t | dr| jS | jd kr.dt| j d | _| jS )NrÚ z~{rü ©r rÚ r¤ r rv rµ ry ry rz r¶ s
|
|
|
zNotAny.__str__)Trº ry ry re rz r ê s
|
|
c s( e Zd Zd fdd ZdddZ ZS ) Ú_MultipleMatchNc sF t t| |¡ d| _|}t|tr.t |¡}|d k r<| nd | _d S rÕ ) rd r$ r r¦ r} rè r& r Ú not_ender)r« rv ÚstopOnÚenderre ry rz r s
|
|
z_MultipleMatch.__init__Tc C s¾ | j j}| j}| jd k }|r$| jj}|r2||| ||||dd\}}zV| j } |r`||| | rp|||}
|
n|}
|
|||
|
|\}} | s| ¡ rR|| 7 }qRW n ttfk
|
r´ Y nX ||fS ©NFr ) rv rÈ rÛ r% rí r¬ r r! rì ) r« ru r¦ r Úself_expr_parseÚself_skip_ignorablesÚ check_enderÚ try_not_enderrè ÚhasIgnoreExprsræ Ú tmptokensry ry rz rá s*
|
|
|
|
z_MultipleMatch.parseImpl)N)T)r r r r rá r ry ry re rz r$
|
s r$ c @ s e Zd ZdZdd ZdS )r a
|
Repetition of one or more of the given expression.
|
|
Parameters:
|
- expr - expression that must match one or more times
|
- stopOn - (default=C{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 C s4 t | dr| jS | jd kr.dt| j d | _| jS )NrÚ rû z}...r# rµ ry ry rz r¶ J s
|
|
|
zOneOrMore.__str__N)r r r rà r¶ ry ry ry rz r 0 s c s8 e Zd ZdZd
|
fdd Zd fdd Zdd Z ZS ) r4 aw
|
Optional repetition of zero or more of the given expression.
|
|
Parameters:
|
- expr - expression that must match zero or more times
|
- stopOn - (default=C{None}) - expression for a terminating sentinel
|
(only required if the sentinel would ordinarily match the repetition
|
expression)
|
|
Example: similar to L{OneOrMore}
|
Nc s t t| j||d d| _d S )N)r& T)rd r4 r rª )r« rv r& re ry rz r _ s zZeroOrMore.__init__Tc s< zt t| |||¡W S ttfk
|
r6 |g f Y S X d S r )rd r4 rá r! rì rà re ry rz rá c s zZeroOrMore.parseImplc C s4 t | dr| jS | jd kr.dt| j d | _| jS )NrÚ r9 ú]...r# rµ ry ry rz r¶ i s
|
|
|
zZeroOrMore.__str__)N)Trº ry ry re rz r4 S s c @ s e Zd Zdd ZeZdd ZdS )Ú
|
_NullTokenc C s dS r ry rµ ry ry rz r s s z_NullToken.__bool__c C s dS r¥ ry rµ ry ry rz r¶ v s z_NullToken.__str__N)r r r r rm r¶ ry ry ry rz r0 r s r0 c s6 e Zd ZdZef fdd Zd ddZdd Z ZS )
|
r aa
|
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 s. t t| j|dd | jj| _|| _d| _d S )NFr T)rd r r rv r¦ r! rª )r« rv r re ry rz r s
|
zOptional.__init__Tc C sz z | j j|||dd\}}W nT ttfk
|
rp | jtk rh| j jr^t| jg}| j|| j j< ql| jg}ng }Y nX ||fS r( )rv rÈ r! rì r! Ú_optionalNotMatchedr¥ r$ )r« ru r¦ r rè ry ry rz rá £ s
|
|
|
zOptional.parseImplc C s4 t | dr| jS | jd kr.dt| j d | _| jS )NrÚ r9 r< r# rµ ry ry rz r¶ ± s
|
|
|
zOptional.__str__)T) r r r rà r1 r rá r¶ r ry ry re rz r z s "
|
c s, e Zd ZdZd fdd Zd
|
ddZ ZS ) r* 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=C{False}) if True, the target expression is also parsed
|
(the skipped text and target expression are returned as a 2-element list).
|
- ignore - (default=C{None}) used to define grammars (typically quoted strings and
|
comments) that might contain false matches to the target expression
|
- failOn - (default=C{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 s` t t| |¡ || _d| _d| _|| _d| _t|t rFt
|
|¡| _ n|| _ dt | j | _d S )NTFzNo match found for )rd r* r Ú
|
ignoreExprrª r¯ Ú includeMatchrÛ r} rè r& r ÚfailOnr rv r° )r« r+ ÚincluderR r4 re ry rz r ñ s
|
zSkipTo.__init__Tc C s& |}t |}| j}| jj}| jd k r,| jjnd }| jd k rB| jjnd } |}
|
|
|
|krÒ|d k rf|||
|
rfqâ| d k rz| ||
|
}
|
W qn tk
|
r Y qY qnX qnz|||
|
ddd W qâ tt fk
|
rÌ |
|
d7 }
|
Y qJX qâqJt||| j
|
| |
|
}|||
} t | } | j r ||||dd\}} | | 7 } || fS )NF)r rà r r ) rø rv rÈ r4 rî r2 rí r r! rì r° r$ r3 )r« ru r¦ r rx rÞ rv Ú
|
expr_parseÚself_failOn_canParseNextÚself_ignoreExpr_tryParseÚtmplocÚskiptextÚ
|
skipresultr ry ry rz rá þ s:
|
zSkipTo.parseImpl)FNN)Tr
ry ry re rz r* º s 6 c sb e Zd ZdZd fdd Zdd Zdd Zd d
|
Zd d Zg fd dZ dd Z
|
fddZ Z S )r aK
|
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 C{Forward} variable using the '<<' operator.
|
|
Note: take care when assigning to C{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 C{Forward}::
|
fwdExpr << (a | b | c)
|
Converting to use the '<<=' operator instead will avoid this problem.
|
|
See L{ParseResults.pprint} for an example of a recursive parser created using
|
C{Forward}.
|
Nc s t t| j|dd d S r )rd r r r7 re ry rz r @ s zForward.__init__c C sj t |trt |¡}|| _d | _| jj| _| jj| _| | jj ¡ | jj
|
| _
|
| jj | _ | j | jj ¡ | S r )r} rè r& r rv r¤ r¯ rª rP r¨ r§ r¦ r¬ r& r7 ry ry rz Ú
|
__lshift__C s
|
|
|
|
|
|
zForward.__lshift__c C s | |> S r ry r7 ry ry rz Ú __ilshift__P s zForward.__ilshift__c C s
|
d| _ | S r rN rµ ry ry rz rO S s zForward.leaveWhitespacec C s$ | j s d| _ | jd k r | j ¡ | S rÕ )r® rv r rµ ry ry rz r W s
|
|
|
zForward.streamlinec C s> | |kr0|d d
| g }| j d k r0| j |¡ | g ¡ d S r r r! ry ry rz r[ ^ s
|
|
zForward.validatec C sV t | dr| jS | jjd S z | jd k r4t| j}nd}W 5 | j| _X | jjd | S )NrÚ z: ...ÚNonez: )r rÚ r r Z _revertClassÚ_ForwardNoRecurserv r )r« Ú retStringry ry rz r¶ e s
|
|
|
zForward.__str__c s. | j d k rtt| ¡ S t }|| K }|S d S r )rv rd r ré rG re ry rz ré v s
|
|
z Forward.copy)N) r r r rà r r< r= rO r r[ r¶ ré r ry ry re rz r - s c @ s e Zd Zdd ZdS )r? c C s dS )Nr· ry rµ ry ry rz r¶ s z_ForwardNoRecurse.__str__N)r r r r¶ ry ry ry rz r? ~ s r? c s" e Zd ZdZd fdd Z ZS )r/ zQ
|
Abstract subclass of C{ParseExpression}, for converting parsed results.
|
Fc s t t| |¡ d| _d S r )rd r/ r r¦ r re ry rz r s zTokenConverter.__init__)Fr ry ry re rz r/ s c s6 e Zd ZdZd
|
fdd Z fddZdd Z ZS ) 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 C{'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 s8 t t| |¡ |r | ¡ || _d| _|| _d| _d S rÕ )rd r r rO Úadjacentr§ Ú
|
joinStringr´ )r« rv rB rA re ry rz r s zCombine.__init__c s( | j rt | |¡ ntt| |¡ | S r )rA r& rR rd r r7 re ry rz rR ¥ s zCombine.ignorec C sP | ¡ }|d d
= |td | | j¡¡g| jd7 }| jrH| ¡ rH|gS |S d S )Nr )rÜ )ré r$ rº r= rB r± r¥ r )r« ru r¦ rã ÚretToksry ry rz rä ¬ s
|
"zCombine.postParse)r T)r r r rà r rR rä r ry ry re rz r s
|
c s( e Zd ZdZ fddZdd Z ZS )r aù
|
Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{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 s t t| |¡ d| _d S rÕ )rd r r r¦ r" re ry rz r Ä s zGroup.__init__c C s |gS r ry râ ry ry rz rä È s zGroup.postParse©r r r rà r rä r ry ry re rz r ¶ s c s( e Zd ZdZ fddZdd Z ZS )r aW
|
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 L{ParseResults} of accessing fields by results name.
|
c s t t| |¡ d| _d S rÕ )rd r r r¦ r" re ry rz r ï s z Dict.__init__c C sî t |D ]Ð\}}t|dkr q|d }t|tr@t|d ¡ }t|dkr\td|||< qt|dkrt|d tst|d |||< q| ¡ }|d= t|dks¶t|trÆ| ¡ rÆt||||< qt|d |||< q| j
|
ræ|gS |S d S )Nr r r rs ) rý rø r} rv r r» rÊ r$ ré r r¥ )r« ru r¦ rã rÐ ÚtokÚikeyÚ dictvaluery ry rz rä ó s$
|
zDict.postParserD ry ry re rz r Ë s # c @ s e Zd ZdZdd Zdd ZdS )r- aV
|
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 L{delimitedList}.)
|
c C s g S r ry râ ry ry rz rä s zSuppress.postParsec C s | S r ry rµ ry ry rz rM " s zSuppress.suppressN)r r r rà rä rM ry ry ry rz r- s c @ s( e Zd ZdZdd Zdd Zdd ZdS ) r zI
|
Wrapper for parse actions, to ensure they are only called once.
|
c C s t || _d| _d S r )r ÚcallableÚcalled)r« Ú
|
methodCallry ry rz r * s
|
zOnlyOnce.__init__c C s. | j s | |||¡}d| _ |S t||dd S )NTr )rI rH r! )r« r r rx r ry ry rz rL - s
|
zOnlyOnce.__call__c C s
|
d| _ d S r )rI rµ ry ry rz Úreset3 s zOnlyOnce.resetN)r r r rà r rL rK ry ry ry rz r & s c s: t fdd}z j|_W n tk
|
r4 Y nX |S )at
|
Decorator for debugging parse actions.
|
|
When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
|
When the parse action completes, the decorator will print C{"<<"} 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'], {}))
|
<<leaving remove_duplicate_chars (ret: 'dfjkls')
|
['dfjkls']
|
c
|
s´ j }| dd
\}}}t| dkr8| d jj d | }tj d|t||||f ¡ z | }W n8 tk
|
r } ztj d||f ¡ W 5 d }~X Y nX tj d||f ¡ |S )Nr rq r Ú.z">>entering %s(line: '%s', %d, %r)
|
z <<leaving %s (exception: %s)
|
z<<leaving %s (ret: %r)
|
)r rø r r ÚstderrÚwriterI r )ÚpaArgsÚthisFuncr r rx r r| ©ra ry rz ÚzL s ztraceParseAction.<locals>.z)r r r² )ra rR ry rQ rz rd 6 s ú,Fc C s` t | d t | d t | d }|rBt| t|| |¡S | tt|| |¡S dS )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 C{combine=True} in the constructor.
|
If C{combine} is set to C{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 [rq r/ N)r r r4 rº r- )rv ÚdelimÚcombineÚdlNamery ry rz rB b s $c sj t fdd}|dkr0tt dd ¡}n| ¡ }| d¡ |j|dd | d t d
|
¡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 C{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 s. |d } |r t tg| p&t t> g S rÒ )r r rE )r r rx r< ©Ú arrayExprrv ry rz ÚcountFieldParseAction s "z+countedArray.<locals>.countFieldParseActionNc S s t | d S rÒ )rv rw ry ry rz r{ r| z countedArray.<locals>.<lambda>ÚarrayLenT©rµ z(len) r· )r r1 rT r ré rº rÎ r )rv ÚintExprrY ry rW rz r> u s
|
c C s6 g }| D ](}t |tr&| t|¡ q| |¡ q|S r )r} rã r& r* r$ )ÚLr rÐ ry ry rz r* s
|
r* c s6 t fdd}| j|dd dt| ¡ S )a*
|
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 C{"1:1"}, but not C{"1:2"}. Because this matches a
|
previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
|
If this is not desired, use C{matchPreviousExpr}.
|
Do I{not} use with packrat parsing enabled.
|
c sP |rBt |dkr |d > qLt| ¡ } tdd |D > n
|
t > d S )Nr r c s s | ]}t |V qd S r )r ©r Úttry ry rz r ² s zDmatchPreviousLiteral.<locals>.copyTokenToRepeater.<locals>.<genexpr>)rø r* rÛ r r )r r rx Útflat©Úrepry rz ÚcopyTokenToRepeater« s z1matchPreviousLiteral.<locals>.copyTokenToRepeaterTr[ ú(prev) )r rÎ rº r )rv rc ry ra rz rQ s
|
|
c sF t | ¡ } |K fdd}| j|dd dt| ¡ S )aS
|
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 C{"1:1"}, but not C{"1:2"}. Because this matches by
|
expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
|
the expressions are evaluated first, and then compared, so
|
C{"1"} is compared with C{"10"}.
|
Do I{not} use with packrat parsing enabled.
|
c s* t | ¡ fdd}j|dd d S )Nc s$ t | ¡ }| kr tdddd S )Nr r )r* rÛ r! )r r rx Ú theseTokens©Ú matchTokensry rz ÚmustMatchTheseTokensÌ s zLmatchPreviousExpr.<locals>.copyTokenToRepeater.<locals>.mustMatchTheseTokensTr[ )r* rÛ r )r r rx rh ra rf rz rc Ê s z.matchPreviousExpr.<locals>.copyTokenToRepeaterTr[ rd )r ré rÎ rº r )rv Úe2rc ry ra rz rP ¹ s c C s: dD ]}| |t| ¡} q| dd¡} | dd¡} t| S )Nz\^-]rH rp rÓ rÖ )r Ú_bslashr )r r¤ ry ry rz r« Õ s
|
r« Tc
|
sÆ |rdd }dd }t ndd }dd }t g }t| trF| ¡ }n$t| trZt| }ntjdt dd |stt
|
S d }|t |d
|
k r|| }t ||d
|
d
D ]R\}} || |rÌ||| d
|
= qxq¦||| r¦||| d
|
= | || ¡ | } qxq¦|d
|
7 }qx|s¤|r¤zlt |t d |¡krTtd d dd |D ¡ d |¡¡W S td dd |D ¡ d |¡¡W S W n& tk
|
r¢ tjdt dd Y nX t fdd|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 C{L{MatchFirst}} for best performance.
|
|
Parameters:
|
- strs - a string of space-delimited literals, or a collection of string literals
|
- caseless - (default=C{False}) - treat all literals as caseless
|
- useRegex - (default=C{True}) - as an optimization, will generate a Regex
|
object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
|
if creating a C{Regex} raises an exception)
|
|
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']]
|
c S s | ¡ | ¡ kS r )r ©r- Úbry ry rz r{ õ r| zoneOf.<locals>.<lambda>c S s | ¡ | ¡ ¡S r )r r rk ry ry rz r{ ö r| c S s | |kS r ry rk ry ry rz r{ ù r| c S s
|
| | ¡S r )r rk ry ry rz r{ ú r| z6Invalid argument to oneOf, expected string or iterablers r2 r r Nr z[%s]c s s | ]}t |V qd S r )r« ©r Úsymry ry rz r s zoneOf.<locals>.<genexpr>r ú|c s s | ]}t |¡V qd S r )r³ r rm ry ry rz r s z7Exception creating Regex for oneOf, building MatchFirstc 3 s | ]} |V qd S r ry rm ©ÚparseElementClassry rz r $ s )r
|
r r} rè r r rã r4 r5 r6 r rø rý r" rº r) rº r r )
|
Ústrsr ÚuseRegexÚisequalÚmasksÚsymbolsrÐ Úcurr r+ ry rp rz rU Ý sT
|
|
|
|
ÿ
|
|
|
** ÿ c C s t tt| | 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 C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{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 C{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'}
|
)r r4 r )r r ry ry rz rC & s !c C s^ t dd ¡}| ¡ }d|_|d| |d }|r@dd }ndd }| |¡ | 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 C{asString} argument is passed as C{False}, then the return value is a
|
C{L{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 C{L{originalTextFor}} contains expressions with defined
|
results names, you must set C{asString} to C{False} if you want to preserve those
|
results name values.
|
|
Example::
|
src = "this is test <b> bold <i>text</i> </b> normal text "
|
for tag in ("b","i"):
|
opener,closer = makeHTMLTags(tag)
|
patt = originalTextFor(opener + SkipTo(closer) + closer)
|
print(patt.searchString(src)[0])
|
prints::
|
['<b> bold <i>text</i> </b>']
|
['<i>text</i>']
|
c S s |S r ry )r r¦ rx ry ry rz r{ a r| z!originalTextFor.<locals>.<lambda>FÚ_original_startÚ _original_endc S s | |j |j
S r )rx ry r~ ry ry rz r{ f r| c S s& | | d¡| d¡
g|d d
< d S )Nrx ry )r r~ ry ry rz Ú extractTexth s z$originalTextFor.<locals>.extractText)r r ré r´ r¬ )rv ÚasStringÚ locMarkerÚ endlocMarkerÚ matchExprrz ry ry rz ri I s
|
|
c C s t | dd ¡S )zp
|
Helper to undo pyparsing's default grouping of And expressions, even
|
if all but one are non-empty.
|
c S s | d S rÒ ry rw ry ry rz r{ s r| zungroup.<locals>.<lambda>)r/ r )rv ry ry rz rj n s c C s4 t dd ¡}t|d| d | ¡ ¡ d 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 C{<TAB>} characters, you may want to call
|
C{L{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 s |S r ry r~ ry ry rz r{ r| z locatedExpr.<locals>.<lambda>Ú
|
locn_startr Úlocn_end)r r r ré rO )rv Úlocatorry ry rz rl u s z\[]-*.$+^?()~ ©r± c C s |d d S r÷ ry r~ ry ry rz r{ r| r{ z\\0?[xX][0-9a-fA-F]+c C s t t|d d¡dS )Nr z\0xé )Úunichrrv Úlstripr~ ry ry rz r{ r| z \\0[0-7]+c C s t t|d dd
dS )Nr r é )r rv r~ ry ry rz r{ r| z\]rò r9 rr ÚnegateÚbodyr< c sF dd z"d fddt | ¡jD ¡W S tk
|
r@ Y dS X dS )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 C{\-} or C{\]})
|
- an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character)
|
(C{\0x##} is also supported for backwards compatibility)
|
- an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
|
- a range of any of the above, separated by a dash (C{'a-z'}, etc.)
|
- any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
|
c S s< t | ts| S d dd tt| d t| d d D ¡S )Nr c s s | ]}t |V qd S r )r r£ ry ry rz r s z+srange.<locals>.<lambda>.<locals>.<genexpr>r r )r} r$ rº rù Úord)Úpry ry rz r{ r| zsrange.<locals>.<lambda>r c 3 s | ]} |V qd S r ry )r Úpart©Ú _expandedry rz r ¯ s zsrange.<locals>.<genexpr>N)rº Ú_reBracketExprr r r r¸ ry r rz ra s
|
"c s fdd}|S )zt
|
Helper method for defining parse actions that require matching at a specific
|
column in the input text.
|
c s" t || kr t| |d d S )Nz matched token not at column %drå )ro Úlocnrz r; ry rz Ú verifyCol¸ s z!matchOnlyAtCol.<locals>.verifyColry )r< r ry r; rz rO ³ s c s fddS )a¹
|
Helper method for common parse actions that simply return a literal value. Especially
|
useful when used with C{L{transformString<ParserElement.transformString>}()}.
|
|
Example::
|
num = Word(nums).setParseAction(lambda toks: int(toks[0]))
|
na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
|
term = na | num
|
|
OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
|
c s gS r ry r~ ©ÚreplStrry rz r{ É r| z replaceWith.<locals>.<lambda>ry r ry r rz r^ ½ s c C s |d dd
S )a
|
Helper parse action for removing quotation marks from parsed quoted strings.
|
|
Example::
|
# by default, quotation marks are included in parsed results
|
quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
|
|
# use removeQuotes to strip quotation marks from parsed results
|
quotedString.setParseAction(removeQuotes)
|
quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
|
r r rt ry r~ ry ry rz r\ Ë s c sN fdd}zt dt dj}W n tk
|
rB t}Y nX ||_|S )aG
|
Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional
|
args are passed, they are forwarded to the given function as additional arguments after
|
the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
|
parsed data to an integer using base 16.
|
|
Example (compare the last to example in L{ParserElement.transformString}::
|
hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
|
hex_ints.runTests('''
|
00 11 22 aa FF 0a 0d 1a
|
''')
|
|
upperword = Word(alphas).setParseAction(tokenMap(str.upper))
|
OneOrMore(upperword).runTests('''
|
my kingdom for a horse
|
''')
|
|
wd = Word(alphas).setParseAction(tokenMap(str.title))
|
OneOrMore(wd).setParseAction(' '.join).runTests('''
|
now is the winter of our discontent made glorious summer by this sun of york
|
''')
|
prints::
|
00 11 22 aa FF 0a 0d 1a
|
[0, 17, 34, 170, 255, 10, 13, 26]
|
|
my kingdom for a horse
|
['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
|
|
now is the winter of our discontent made glorious summer by this sun of york
|
['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
|
c s fdd|D S )Nc s g | ]}|f qS ry ry )r Útokn©rª r ry rz rð ú s z(tokenMap.<locals>.pa.<locals>.<listcomp>ry r~ r ry rz rÔ ù s ztokenMap.<locals>.par r )r r r r )r rª rÔ r ry r rz ro Ù s
|
ÿc C s t | ¡ S r ©r r rw ry ry rz r{ r| c C s t | ¡ S r ©r Úlowerrw ry ry rz r{ r| c C s¢ t | tr | }t| | d} n| j}tttd }|rt ¡ t
|
¡}t d| d t t t|t d | tddgd d ¡ d
|
d ¡ t d }nd dd tD ¡}t ¡ t
|
¡t|B }t d| d t t t| t¡tt d| tddgd d ¡ dd ¡ t d }ttd| d }| dd | dd¡ ¡ ¡ ¡ ¡ d| ¡}| dd | dd¡ ¡ ¡ ¡ ¡ d| ¡}||_||_||fS )zRInternal helper to construct opening and closing tag expressions, given a tag namer z_-:rL Útagú=ú/F©r rE c S s |d dkS ©Nr r ry r~ ry ry rz r{ r| z_makeTags.<locals>.<lambda>rM r c s s | ]}|d kr|V qdS )rM Nry r£ ry ry rz r s z _makeTags.<locals>.<genexpr>c S s |d dkS r ry r~ ry ry rz r{ r| rN r ú:rq z<%s>r² z</%s>) r} rè r rÚ r1 r6 r5 r@ ré r r\ r- r r4 r r r¿ rº rX r[ rD r Ú_Lr Útitler rº r )ÚtagStrÚxmlÚresnameÚ tagAttrNameÚ tagAttrValueÚopenTagZprintablesLessRAbrackÚcloseTagry ry rz Ú _makeTags s>
|
ÿ þþÿÿ ýý..r§ c C s
|
t | dS )a
|
Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
|
tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.
|
|
Example::
|
text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
|
# makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
|
a,a_end = makeHTMLTags("A")
|
link_expr = a + SkipTo(a_end)("link_text") + a_end
|
|
for link in link_expr.searchString(text):
|
# attributes in the <A> tag (like "href" shown here) are also accessible as named results
|
print(link.link_text, '->', link.href)
|
prints::
|
pyparsing -> http://pyparsing.wikispaces.com
|
F©r§ ©r ry ry rz rM ( s c C s
|
t | dS )zº
|
Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
|
tags only in the given upper/lower case.
|
|
Example: similar to L{makeHTMLTags}
|
Tr¨ r© ry ry rz rN ; s c s8 | r| dd
n| ¡ dd D fdd}|S )a<
|
Helper to create a validating parse action to be used with start tags created
|
with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
|
with a required attribute value, to avoid false matches on common tags such as
|
C{<TD>} or C{<DIV>}.
|
|
Call C{withAttribute} with a series of attribute names and values. Specify the list
|
of filter attributes names and values as:
|
- keyword arguments, as in C{(align="right")}, or
|
- as an explicit dict with C{**} operator, when an attribute name is also a Python
|
reserved word, as in C{**{"class":"Customer", "align":"right"}}
|
- a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
|
For attribute names with a namespace prefix, you must use the second form. Attribute
|
names are matched insensitive to upper/lower case.
|
|
If just testing for C{class} (with or without a namespace), use C{L{withClass}}.
|
|
To verify that the attribute exists, but without specifying a value, pass
|
C{withAttribute.ANY_VALUE} as the value.
|
|
Example::
|
html = '''
|
<div>
|
Some text
|
<div type="grid">1 4 0 1 0</div>
|
<div type="graph">1,3 2,3 1,1</div>
|
<div>this has no type</div>
|
</div>
|
|
'''
|
div,div_end = makeHTMLTags("div")
|
|
# only match div tag having a type attribute with value "grid"
|
div_grid = div().setParseAction(withAttribute(type="grid"))
|
grid_expr = div_grid + SkipTo(div | div_end)("body")
|
for grid_header in grid_expr.searchString(html):
|
print(grid_header.body)
|
|
# construct a match with any div tag having a type attribute, regardless of the value
|
div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
|
div_expr = div_any_type + SkipTo(div | div_end)("body")
|
for div_header in div_expr.searchString(html):
|
print(div_header.body)
|
prints::
|
1 4 0 1 0
|
|
1 4 0 1 0
|
1,3 2,3 1,1
|
Nc S s g | ]\}}||fqS ry ry rD ry ry rz rð z s z!withAttribute.<locals>.<listcomp>c sZ D ]P\}}||kr$t | |d| |tjkr|| |krt | |d||| |f qd S )Nzno matching attribute z+attribute '%s' has value '%s', must be '%s')r! rg Ú ANY_VALUE)r r rè ÚattrNameÚ attrValue©Úattrsry rz rÔ { s ÿzwithAttribute.<locals>.pa)rü )rª ÚattrDictrÔ ry r rz rg D s 2 c C s |r d| nd}t f || iS )aã
|
Simplified version of C{L{withAttribute}} when matching on a div class - made
|
difficult because C{class} is a reserved word in Python.
|
|
Example::
|
html = '''
|
<div>
|
Some text
|
<div class="grid">1 4 0 1 0</div>
|
<div class="graph">1,3 2,3 1,1</div>
|
<div>this <div> has no class</div>
|
</div>
|
|
'''
|
div,div_end = makeHTMLTags("div")
|
div_grid = div().setParseAction(withClass("grid"))
|
|
grid_expr = div_grid + SkipTo(div | div_end)("body")
|
for grid_header in grid_expr.searchString(html):
|
print(grid_header.body)
|
|
div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
|
div_expr = div_any_type + SkipTo(div | div_end)("body")
|
for div_header in div_expr.searchString(html):
|
print(div_header.body)
|
prints::
|
1 4 0 1 0
|
|
1 4 0 1 0
|
1,3 2,3 1,1
|
z%s:classÚclass)rg )Ú classnameÚ namespaceÚ classattrry ry rz rm
s ú(rÄ c C s t }| || | B }t|D ]l\}}|d dd
\}} }
|
} | dk rPd| nd| } | dkr|dkstt|dkr|td|\} }t | ¡}|
|
tjkr^| d krÂt|| t|t | }n| dkr|dk rút|| | t|t || }n t|| t|t | }nD| dkrTt|| | | | t|| | | | }ntd
|
nì|
|
tj
|
krB| d kr¤t |t st |}t|j | t|| }n| dkrü|dk rÞt|| | t|t || }n t|| t|t | }nD| dkr8t|| | | | t|| | | | }ntd
|
ntd | rvt | ttfrl|j| n
|
| | ¡ || | ¡|B K }|}q ||K }|S ) aD
|
|
Helper method for constructing grammars of expressions made up of
|
operators working in a precedence hierarchy. Operators may be unary or
|
binary, left- or right-associative. Parse actions can also be attached
|
to operator expressions. The generated parser will also recognize the use
|
of parentheses to override operator precedences (see example below).
|
|
Note: if you define a deep operator list, you may see performance issues
|
when using infixNotation. See L{ParserElement.enablePackrat} for a
|
mechanism to potentially improve your parser performance.
|
|
Parameters:
|
- baseExpr - expression representing the most basic element for the nested
|
- opList - list of tuples, one for each operator precedence level in the
|
expression grammar; each tuple is of the form
|
(opExpr, numTerms, rightLeftAssoc, parseAction), where:
|
- opExpr is the pyparsing expression for the operator;
|
may also be a string, which will be converted to a Literal;
|
if numTerms is 3, opExpr is a tuple of two expressions, for the
|
two operators separating the 3 terms
|
- numTerms is the number of terms for this operator (must
|
be 1, 2, or 3)
|
- rightLeftAssoc is the indicator whether the operator is
|
right or left associative, using the pyparsing-defined
|
constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
|
- parseAction is the parse action to be associated with
|
expressions matching this operator expression (the
|
parse action tuple member may be omitted); if the parse action
|
is passed a tuple or list of functions, this is equivalent to
|
calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})
|
- lpar - expression for matching left-parentheses (default=C{Suppress('(')})
|
- rpar - expression for matching right-parentheses (default=C{Suppress(')')})
|
|
Example::
|
# simple example of four-function arithmetic with ints and variable names
|
integer = pyparsing_common.signed_integer
|
varname = pyparsing_common.identifier
|
|
arith_expr = infixNotation(integer | varname,
|
[
|
('-', 1, opAssoc.RIGHT),
|
(oneOf('* /'), 2, opAssoc.LEFT),
|
(oneOf('+ -'), 2, opAssoc.LEFT),
|
])
|
|
arith_expr.runTests('''
|
5+3*6
|
(5+3)*6
|
-2--11
|
''', fullDump=False)
|
prints::
|
5+3*6
|
[[5, '+', [3, '*', 6]]]
|
|
(5+3)*6
|
[[[5, '+', 3], '*', 6]]
|
|
-2--11
|
[[['-', 2], '-', ['-', 11]]]
|
r Nr¶ rq z%s termz %s%s termrs z@if numterms=3, opExpr must be a tuple or list of two expressionsr z6operator must be unary (1), binary (2), or ternary (3)z2operator must indicate right or left associativity)r rý rø r@ rº rV ÚLEFTr r r ÚRIGHTr} r rv r? rã r )ÚbaseExprÚopListÚlparÚrparr ÚlastExprrÐ ÚoperDefÚopExprÚarityÚrightLeftAssocrÔ ÚtermNameÚopExpr1ÚopExpr2ÚthisExprr~ ry ry rz rk ¬ sZ =
|
&
|
ÿ
|
|
|
|
&
|
ÿ
|
|
z4"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*ú"z string enclosed in double quotesz4'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*ú'z string enclosed in single quotesz*quotedString using single or double quotesÚuzunicode string literalc C s | |krt d|dkr*t| tr"t|tr"t| dkr¨t|dkr¨|dk rtt| t| | tj dd dd ¡}n$t
|
¡ t| | tj dd ¡ }nx|dk rìtt| t | t | ttjdd dd ¡}n4ttt | t | ttjdd d d ¡}nt d
|
t }|dk rd|tt| t||B |B t| K }n$|tt| t||B t| K }| d | |f ¡ |S ) a~
|
Helper method for defining nested lists enclosed in opening and closing
|
delimiters ("(" and ")" are the default).
|
|
Parameters:
|
- opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
|
- closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
|
- content - expression for items within the nested lists (default=C{None})
|
- ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})
|
|
If an expression is not provided for the content argument, the nested
|
expression will capture all whitespace-delimited content between delimiters
|
as a list of separate values.
|
|
Use the C{ignoreExpr} argument to define expressions that may contain
|
opening or closing characters that should not be treated as opening
|
or closing characters for nesting, such as quotedString or a comment
|
expression. Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
|
The default is L{quotedString}, but if no expressions are to be ignored,
|
then pass C{None} for this argument.
|
|
Example::
|
data_type = oneOf("void int short long char float double")
|
decl_data_type = Combine(data_type + Optional(Word('*')))
|
ident = Word(alphas+'_', alphanums+'_')
|
number = pyparsing_common.number
|
arg = Group(decl_data_type + ident)
|
LPAR,RPAR = map(Suppress, "()")
|
|
code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))
|
|
c_function = (decl_data_type("type")
|
+ ident("name")
|
+ LPAR + Optional(delimitedList(arg), [])("args") + RPAR
|
+ code_body("body"))
|
c_function.ignore(cStyleComment)
|
|
source_code = '''
|
int is_odd(int x) {
|
return (x%2);
|
}
|
|
int dec_to_hex(char hchar) {
|
if (hchar >= '0' && hchar <= '9') {
|
return (ord(hchar)-ord('0'));
|
} else {
|
return (10+ord(hchar)-ord('A'));
|
}
|
}
|
'''
|
for func in c_function.searchString(source_code):
|
print("%(name)s (%(type)s) args: %(args)s" % func)
|
|
prints::
|
is_odd (int) args: [['int', 'x']]
|
dec_to_hex (int) args: [['char', 'hchar']]
|
z.opening and closing strings cannot be the sameNr r c S s | d ¡ S rÒ ©r» rw ry ry rz r{ g r| z nestedExpr.<locals>.<lambda>c S s | d ¡ S rÒ rÇ rw ry ry rz r{ j r| c S s | d ¡ S rÒ rÇ rw ry ry rz r{ p r| c S s | d ¡ S rÒ rÇ rw ry ry rz r{ t r| zOopening and closing arguments must be strings if no content expression is givenznested %s%s expression)r@ r} rè rø r r r r& r r rE ré r r r r- r4 rº )ÚopenerÚcloserÚcontentr2 r ry ry rz rR % sH :
|
ÿþÿÿÿ þý ÿþ
|
*$c sä fdd} fdd} fdd}t t d¡ ¡ }t t |¡ d¡}t |¡ d ¡}t |¡ d
|
¡} |r¦tt|| t |t| t| | }
|
n$tt|t |t| t| }
|
| t
|
t ¡ |
|
d ¡S ) a
|
|
Helper method for defining space-delimited indentation blocks, such as
|
those used to define block statements in Python source code.
|
|
Parameters:
|
- blockStatementExpr - expression defining syntax of statement that
|
is repeated within the indented block
|
- indentStack - list created by caller to manage indentation stack
|
(multiple statementWithIndentedBlock expressions within a single grammar
|
should share a common indentStack)
|
- indent - boolean indicating whether block must be indented beyond the
|
the current level; set to False for block of left-most statements
|
(default=C{True})
|
|
A valid block must contain at least one C{blockStatement}.
|
|
Example::
|
data = '''
|
def A(z):
|
A1
|
B = 100
|
G = A2
|
A2
|
A3
|
B
|
def BB(a,b,c):
|
BB1
|
def BBA():
|
bba1
|
bba2
|
bba3
|
C
|
D
|
def spam(x,y):
|
def eggs(z):
|
pass
|
'''
|
|
|
indentStack = [1]
|
stmt = Forward()
|
|
identifier = Word(alphas, alphanums)
|
funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
|
func_body = indentedBlock(stmt, indentStack)
|
funcDef = Group( funcDecl + func_body )
|
|
rvalue = Forward()
|
funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
|
rvalue << (funcCall | identifier | Word(nums))
|
assignment = Group(identifier + "=" + rvalue)
|
stmt << ( funcDef | assignment | identifier )
|
|
module_body = OneOrMore(stmt)
|
|
parseTree = module_body.parseString(data)
|
parseTree.pprint()
|
prints::
|
[['def',
|
'A',
|
['(', 'z', ')'],
|
':',
|
[['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
|
'B',
|
['def',
|
'BB',
|
['(', 'a', 'b', 'c', ')'],
|
':',
|
[['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
|
'C',
|
'D',
|
['def',
|
'spam',
|
['(', 'x', 'y', ')'],
|
':',
|
[[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]
|
c sN |t | krd S t|| }| d krJ| d kr>t| |dt| |dd S )Nrt zillegal nestingznot a peer entry)rø r; r# r! ©r r rx ÚcurCol©Ú indentStackry rz ÚcheckPeerIndentÍ s
|
z&indentedBlock.<locals>.checkPeerIndentc s2 t || }| d kr" |¡ n t| |dd S )Nrt znot a subentry)r; r$ r! rË rÍ ry rz ÚcheckSubIndentÕ s
|
z%indentedBlock.<locals>.checkSubIndentc sN |t | krd S t|| } r6| d k r6| d ksBt| |d ¡ d S )Nrt r znot an unindent)rø r; r! r rË rÍ ry rz Ú checkUnindentÜ s
|
z$indentedBlock.<locals>.checkUnindentz ÚINDENTr ÚUNINDENTzindented block) r r rP rM r r rº r r rR rj ) ÚblockStatementExprrÎ rR rÏ rÐ rÑ re rÒ ÚPEERÚUNDENTÚsmExprry rÍ rz rh s( N þþþÿz#[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]z[\0xa1-\0xbf\0xd7\0xf7]z_:zany tagzgt lt amp nbsp quot aposz><& "'z &(?P<entity>ro z);zcommon HTML entityc C s t | j¡S )zRHelper parser action to replace common HTML entities with their special characters)Ú_htmlEntityMaprò Úentityrw ry ry rz r] ÷ s z/\*(?:[^*]|\*(?!/))*z*/zC style commentz<!--[\s\S]*?-->z HTML commentz.*z rest of linez//(?:\\\n|[^\n])*z
|
// commentzC++ style commentz#.*zPython style commentr¡ ú Ú commaItemr c @ s¨ e Zd ZdZeeZeeZe e
|
d¡ e¡Z e e d¡ eed¡Zed d¡ e¡Ze e¡d e e¡ d¡Ze d d
|
¡ eeeed ¡ e B d ¡Ze e¡ ed d¡ e¡Zed d¡ e¡ZeeB eB ¡ Zed d¡ e¡Z e e d e d d¡Z ed d¡Z ed d¡Z!e!de! d d¡Z"ee!de! d d ee!de! d d ¡Z#e# $d d
|
¡ d e d!¡Z%e&e"e%B e#B d"¡ d"¡Z'ed# d$¡Z(e)d=d&d'Z*e)d>d)d*Z+ed+ d,¡Z,ed- d.¡Z-ed/ d0¡Z.e/ ¡ e0 ¡ B Z1e)d1d2 Z2e&e3e4d3 e5 e e6d3d4 ee7d5 ¡ d6¡Z8e9ee: ;¡ e8B d7d8 d9¡Z<e)ed:d
|
Z=e)ed;d
|
Z>d<S )?rp a®
|
|
Here are some common low-level expressions that may be useful in jump-starting parser development:
|
- numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})
|
- common L{programming identifiers<identifier>}
|
- network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})
|
- ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}
|
- L{UUID<uuid>}
|
- L{comma-separated list<comma_separated_list>}
|
Parse actions:
|
- C{L{convertToInteger}}
|
- C{L{convertToFloat}}
|
- C{L{convertToDate}}
|
- C{L{convertToDatetime}}
|
- C{L{stripHTMLTags}}
|
- C{L{upcaseTokens}}
|
- C{L{downcaseTokens}}
|
|
Example::
|
pyparsing_common.number.runTests('''
|
# any int or real number, returned as the appropriate type
|
100
|
-100
|
+100
|
3.14159
|
6.02e23
|
1e-12
|
''')
|
|
pyparsing_common.fnumber.runTests('''
|
# any int or real number, returned as float
|
100
|
-100
|
+100
|
3.14159
|
6.02e23
|
1e-12
|
''')
|
|
pyparsing_common.hex_integer.runTests('''
|
# hex numbers
|
100
|
FF
|
''')
|
|
pyparsing_common.fraction.runTests('''
|
# fractions
|
1/2
|
-3/4
|
''')
|
|
pyparsing_common.mixed_integer.runTests('''
|
# mixed fractions
|
1
|
1/2
|
-3/4
|
1-3/4
|
''')
|
|
import uuid
|
pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
|
pyparsing_common.uuid.runTests('''
|
# uuid
|
12345678-1234-5678-1234-567812345678
|
''')
|
prints::
|
# any int or real number, returned as the appropriate type
|
100
|
[100]
|
|
-100
|
[-100]
|
|
+100
|
[100]
|
|
3.14159
|
[3.14159]
|
|
6.02e23
|
[6.02e+23]
|
|
1e-12
|
[1e-12]
|
|
# any int or real number, returned as float
|
100
|
[100.0]
|
|
-100
|
[-100.0]
|
|
+100
|
[100.0]
|
|
3.14159
|
[3.14159]
|
|
6.02e23
|
[6.02e+23]
|
|
1e-12
|
[1e-12]
|
|
# hex numbers
|
100
|
[256]
|
|
FF
|
[255]
|
|
# fractions
|
1/2
|
[0.5]
|
|
-3/4
|
[-0.75]
|
|
# mixed fractions
|
1
|
[1]
|
|
1/2
|
[0.5]
|
|
-3/4
|
[-0.75]
|
|
1-3/4
|
[1.75]
|
|
# uuid
|
12345678-1234-5678-1234-567812345678
|
[UUID('12345678-1234-5678-1234-567812345678')]
|
Úintegerz hex integerr z[+-]?\d+zsigned integerr Úfractionc C s | d | d S )Nr rt ry rw ry ry rz r{ ´ r| zpyparsing_common.<lambda>rò z"fraction or mixed integer-fractionz [+-]?\d+\.\d*z real numberz+[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)z$real number with scientific notationz [+-]?\d+\.?\d*([eE][+-]?\d+)?Úfnumberr Ú
|
identifierzK(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}z IPv4 addressz[0-9a-fA-F]{1,4}Ú hex_integerr é zfull IPv6 address)r r z::zshort IPv6 addressc C s t dd | D dk S )Nc s s | ]}t j |¡rd V qdS rI )rp Ú
|
_ipv6_partr% r^ ry ry rz r Ð s z,pyparsing_common.<lambda>.<locals>.<genexpr>r )r rw ry ry rz r{ Ð r| z::ffff:zmixed IPv6 addressz IPv6 addressz:[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}z MAC addressú%Y-%m-%dc s fdd}|S )aØ
|
Helper to create a parse action for converting parsed date string to Python datetime.date
|
|
Params -
|
- fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})
|
|
Example::
|
date_expr = pyparsing_common.iso8601_date.copy()
|
date_expr.setParseAction(pyparsing_common.convertToDate())
|
print(date_expr.parseString("1999-12-31"))
|
prints::
|
[datetime.date(1999, 12, 31)]
|
c
|
sN zt |d ¡ ¡ W S tk
|
rH } zt| |t|W 5 d }~X Y nX d S rÒ )r ÚstrptimeÚdater@ r! r ©r r rx Úve©Úfmtry rz Úcvt_fnç s z.pyparsing_common.convertToDate.<locals>.cvt_fnry ©ré rê ry rè rz Ú convertToDateØ s z pyparsing_common.convertToDateú%Y-%m-%dT%H:%M:%S.%fc s fdd}|S )a
|
Helper to create a parse action for converting parsed datetime string to Python datetime.datetime
|
|
Params -
|
- fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})
|
|
Example::
|
dt_expr = pyparsing_common.iso8601_datetime.copy()
|
dt_expr.setParseAction(pyparsing_common.convertToDatetime())
|
print(dt_expr.parseString("1999-12-31T23:59:59.999"))
|
prints::
|
[datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
|
c
|
sJ zt |d ¡W S tk
|
rD } zt| |t|W 5 d }~X Y nX d S rÒ )r rä r@ r! r ræ rè ry rz rê ý s z2pyparsing_common.convertToDatetime.<locals>.cvt_fnry rë ry rè rz ÚconvertToDatetimeî s z"pyparsing_common.convertToDatetimez7(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?z ISO8601 datez(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?zISO8601 datetimez2[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}ÚUUIDc C s t j |d ¡S )a
|
Parse action to remove HTML tags from web page HTML source
|
|
Example::
|
# strip HTML links from normal text
|
text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
|
td,td_end = makeHTMLTags("TD")
|
table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
|
|
print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
|
r )rp Ú_html_stripperr
)r r rè ry ry rz Ú stripHTMLTags s z pyparsing_common.stripHTMLTagsrS r¡ rÚ rÛ r r zcomma separated listc C s t | ¡ S r r rw ry ry rz r{ " r| c C s t | ¡ S r r rw ry ry rz r{ % r| N)rã )rí )?r r r rà ro rv ÚconvertToIntegerÚfloatÚconvertToFloatr1 rT rº r rÜ rF rà r) Úsigned_integerrÝ rÎ r rM Ú mixed_integerr ÚrealÚsci_realr ÚnumberrÞ r6 r5 rß Ú ipv4_addressrâ Ú_full_ipv6_addressÚ_short_ipv6_addressrÕ Ú_mixed_ipv6_addressr Ú ipv6_addressÚ mac_addressr rì rî Ú iso8601_dateÚiso8601_datetimeÚuuidr9 r8 rð rñ r r r rX r0 Ú _commasepitemrB r[ ré Úcomma_separated_listrf rD ry ry ry rz rp sV ""
|
2
|
|
ÿ ÿ Ú__main__ÚselectÚfromr rL )rU Úcolumnsr» ZtablesÚcommandaK
|
# '*' as column list and dotted table name
|
select * from SYS.XYZZY
|
|
# caseless match on "SELECT", and casts back to "select"
|
SELECT * from XYZZY, ABC
|
|
# list of column names, and mixed case SELECT keyword
|
Select AA,BB,CC from Sys.dual
|
|
# multiple tables
|
Select A, B, C from Sys.dual, Table2
|
|
# invalid SELECT keyword - should fail
|
Xelect A, B, C from Sys.dual
|
|
# incomplete command - should fail
|
Select
|
|
# invalid column name - should fail
|
Select ^^^ frox Sys.dual
|
|
z]
|
100
|
-100
|
+100
|
3.14159
|
6.02e23
|
1e-12
|
z
|
100
|
FF
|
z6
|
12345678-1234-5678-1234-567812345678
|
)rs )rS F)N)FT)T)r )T)ãrÃ Ú __version__Ú__versionTime__Ú
|
__author__r¡ Úweakrefr ró ré r r4 r³ r¾ r rf r rú r Ú_threadr Ú ImportErrorÚ threadingÚcollections.abcr r r r Z ordereddictÚ__all__r? Ú version_infor rE Úmaxsizer r rè Úchrr r r rø r` Úreversedrã rö rb rí r¯ r° r ZmaxintÚxrangerù Ú __builtin__r Úfnamer$ r r² rÁ rå r rÖ r Úascii_uppercaseÚascii_lowercaser6 rT rF r5 rj rº Ú printablerX r r r! r# r% r( rÊ r$ Úregisterr; rL rI rw r{ r} rS r r& r. r r r r r r r
|
r rn r1 r) r' r r0 rá r r r r, r+ r3 r2 r" r r r r r r r r$ r r4 r0 r1 r r* r r? r/ r r r r- r rd rB r> r* rQ rP r« rU rC ri rj rl rº rE rK rJ rc rb r Ú _escapedPuncÚ_escapedHexCharÚ_escapedOctCharÚ _singleCharÚ
|
_charRanger¿ r ra rO r^ r\ ro rf rD r§ rM rN rg rª rm rV rµ r¶ rk rW r@ r` r[ re rR rh r7 rY r9 r8 ræ r rØ r r= r] r: rG rO r_ rA r? rH rZ r r r< rp r Z selectTokenZ fromTokenÚidentZ
|
columnNameZcolumnNameListZ
|
columnSpecZ tableNameZ tableNameListZ simpleSQLr~ rù rÞ rà r rï ry ry ry rz Ú<module> s¦ ÿ4 î
|
8
|
|
|
@ v &A= I
|
G3 pLOD|M &# @sQ,A, I# % 0
|
, ? #p
|
ÿÿ Zr
|
|
(
|
|
ÿÿÿ þ
|
|
|
"
|
|
