U
|
H=®dò+ ã t @ s d Z dZdZdZddlZddlmZ ddlZddl Z ddl
|
Z
|
ddl Z ddl Z ddl Z ddlZddlZddlZddlmZ ddlmZ ddlZdd lmZ dd
|
lmZ zdd lmZ W n ek
|
rÔ dd lmZ Y nX zdd l m Z W n" ek
|
r dd l m Z Y nX z ddl m Z ddl m!Z!m"Z" W n2 ek
|
r\ ddl m Z ddl m!Z!m"Z" Y nX zddl m#Z$ W nB ek
|
r° zddl%m#Z$ W n ek
|
rª dZ$Y nX Y nX zddlm&Z& W n$ ek
|
ræ G dd dZ&Y nX e& Z'de'_ de'_(e& Z)de)_ de)_*de)_+de)_,de)_-de)_.dd e/e)D e)_0dd Z1e1e)_2d 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`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~ddddddd
ddddddddddgtZ3e4e j5dd
Z6e6d dkZ7e7re j8Z9e:Z;e<Z=e:Z>e:Z?e@eAeBeCeDe4eEeFeGeHeIg ZJn`e jKZ9eLZMdd Z?g ZJddlNZNd O¡ D ]8ZPzeJ QeReNeP¡ W n eSk
|
râ Y q®Y nX q®eTdd eMdD ZUdd ZVejWejX ZYdZZeZd Z[eYeZ Z\e<dZ]d ^dd ej_D ¡Z`daddZaG dd9 d9ebZcG d d; d;ecZdG d¡d= d=ecZeG d¢d? d?eeZfG d£dB dBebZgG d¤d¥ d¥ehZiG d¦d> d>ehZje! kej¡ d§dV Zld¨dg Zmd©dd Zndªd« Zod¬d Zpd®d¯ Zqd°dn Zrdbd²d³ZsG d´d@ d@ehZtG dµd¶ d¶etZuG d·dH dHetZvG d¸d( d(evZwG d¹d3 d3evZxG dºd0 d0evZyG d»d¼ d¼eyZzeyZ{eyet_|G d½d- d-evZ}G d¾d# d#eyZ~G d¿d" d"e}ZG dÀd devZG dÁdK dKevZG dÂdà dÃeZG dÄdO dOeZG dÅdC dCevZG dÆdA dAevZ
G dÇd$ d$evZG dÈdJ dJevZG dÉdÊ dÊevZG dËd+ d+eZG dÌd/ d/eZG dÍd. d.eZG dÎdF dFeZG dÏdE dEeZG dÐdM dMeZG dÑdL dLeZG dÒd< d<etZG dÓd! d!eZG dÔd8 d8eZG dÕd2 d2eZG dÖd' d'eZG d×d: d:etZG dØd) d)eZG dÙd1 d1eZG dÚd4 d4eZG dÛdÜ dÜeZG dÝd5 d5eZG dÞdN dNeZG dßdà dàehZG dád7 d7eZG dâdD dDeZG dãd* d*eZG dädI dIeZ G dåd% d%e Z¡G dæd, d,e Z¢G dçd& d&e Z£G dèdG dGe Z¤G déd6 d6ehZ¥dêd Z¦dcdìd]Z§dddídYZ¨dîdï Z©dðdl Zªdñdk Z«dòdó Z¬dedôdpZdõd^ Z®dfdödZ¯d÷d
Z°død Z±ew ²d`¡Z³e ²df¡Z´e ²de¡Zµe ²d~¡Z¶e ²d}¡Z·ee]dùd±dú ¸dûdü ¡Z¹edý ¸dþdü ¡Zºedÿ ¸d dü ¡Z»e¹eºB e»B edddúB Z¼e¢e¼e¤d e¼ Z½eyded ¾d¡ e¢ee½e¼B ¾d¡ d Z¿dd| ZÀd dj ZÁd
|
dy ZÂd dw ZÃd d ZÄeÄd dü ZÅeÄddü ZÆe¤de¤dfddZÇddh ZÈddi ZÉdd ZÊeh eÊ_ËdgddZÌe& ZÍeh eÍ_Îeh eÍ_Ïe¤de¤dfddZÐeÐZÑe¡edd ²d ¡ZÒe¡ed d ²d ¡ZÓe¡edd ed d B ²d ¡ZÔe¡e{d!eÔ ¡ ²d"¡ZÕdddeÔ ¡ fd#dmZÖdhd$dZ×eÀd%ZØeÀd&ZÙeÈeeYe\d' ²d(¡\ZÚZÛeÜeÝd) O¡ d*ZÞed+d, ^eÞ ß¡ ¡ d- ²d.¡Zàd/dx Záe¡ed0d1 ²d2¡Zâed3 ²d4¡Zãed5 ä¡ ²d6¡Zåed7 ²d8¡Zæe¡ed0d1 eæB ²d9¡ZçeçZèed: ²d;¡Zée¡eee`dëd<eed=eydë e ê¡ ²d>¡Zëe§eeÔ ¡ eëB dd? ²dW¡ZìG d@d dZíG dAdB dBehZîG dCd dehZïG dDd deïZðeðjñjòjóeðjñjôjó eðjñjõjó eðjñ_óe7 reöeðdEeðj÷ eöeðdFeðjø eöeðdGeðjù eöeðdHeðjú eöeðdIeðjû eöeðdJeðjñ eöeðjñdKeðjñjò eöeðjñdLeðjñjõ eöeðjñdMeðjñjô eöeðdNeðjü eöeðdOeðjý eöeðdPeðjþ G dQdR dRZÿe dSkr e~dTZe~dUZeeYe\dV Ze§edWddX ¸eÅ¡Ze¢e§e ²dY¡ZdZeB Ze§edWddX ¸eÅ¡Ze¢e§e ²d[¡Zed\edY e ed[ Z e
|
d]¡ eíj
|
d^¡ eíj
|
d^¡ eíj
|
d_¡ ddlZeíj ¸eÄej¡ eíj
|
d`¡ dS (i 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
|
``"<salutation>, <addressee>!"``), built up using :class:`Word`,
|
:class:`Literal`, and :class:`And` elements
|
(the :class:`'+'<ParserElement.__add__>` operators create :class:`And` expressions,
|
and the strings are auto-converted to :class:`Literal` expressions)::
|
|
from pip._vendor.pyparsing import Word, alphas
|
|
# define grammar of a greeting
|
greet = Word(alphas) + "," + Word(alphas) + "!"
|
|
hello = "Hello, World!"
|
print (hello, "->", greet.parseString(hello))
|
|
The program outputs the following::
|
|
Hello, World! -> ['Hello', ',', 'World', '!']
|
|
The Python representation of the grammar is quite readable, owing to the
|
self-explanatory class names, and the use of '+', '|' and '^' operators.
|
|
The :class:`ParseResults` object returned from
|
:class:`ParserElement.parseString` can be
|
accessed as a nested list, a dictionary, or an object with named
|
attributes.
|
|
The pyparsing module handles some of the problems that are typically
|
vexing when writing text parsers:
|
|
- extra or missing whitespace (the above program will also handle
|
"Hello,World!", "Hello , World !", etc.)
|
- quoted strings
|
- embedded comments
|
|
|
Getting Started -
|
-----------------
|
Visit the classes :class:`ParserElement` and :class:`ParseResults` to
|
see the base classes that most other pyparsing
|
classes inherit from. Use the docstrings for examples of how to:
|
|
- construct literal match expressions from :class:`Literal` and
|
:class:`CaselessLiteral` classes
|
- construct character word-group expressions using the :class:`Word`
|
class
|
- see how to create repetitive expressions using :class:`ZeroOrMore`
|
and :class:`OneOrMore` classes
|
- use :class:`'+'<And>`, :class:`'|'<MatchFirst>`, :class:`'^'<Or>`,
|
and :class:`'&'<Each>` operators to combine simple expressions into
|
more complex ones
|
- associate names with your parsed results using
|
:class:`ParserElement.setResultsName`
|
- access the parsed data, which is returned as a :class:`ParseResults`
|
object
|
- find some helpful expression short-cuts like :class:`delimitedList`
|
and :class:`oneOf`
|
- find more useful common expressions in the :class:`pyparsing_common`
|
namespace class
|
z2.4.7z30 Mar 2020 00:43 UTCz*Paul McGuire <ptmcg@users.sourceforge.net>é N)Úref)Údatetime)Ú
|
itemgetter)Úwraps)Úcontextmanager)Ú filterfalse)Ú ifilterfalse)ÚRLock)ÚIterable)ÚMutableMappingÚMapping)Ú OrderedDict)ÚSimpleNamespacec @ s e Zd ZdS )r N)Ú__name__Ú
|
__module__Ú __qualname__© r r úLD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pip/_vendor/pyparsing.pyr s r aA
|
A cross-version compatibility configuration for pyparsing features that will be
|
released in a future version. By setting values in this configuration to True,
|
those features can be enabled in prior versions for compatibility development
|
and testing.
|
|
- collect_all_And_tokens - flag to enable fix for Issue #63 that fixes erroneous grouping
|
of results names when an And expression is nested within an Or or MatchFirst; set to
|
True to enable bugfix released in pyparsing 2.3.0, or False to preserve
|
pre-2.3.0 handling of named results
|
Ta
|
Diagnostic configuration (all default to False)
|
- warn_multiple_tokens_in_named_alternation - flag to enable warnings when a results
|
name is defined on a MatchFirst or Or expression with one or more And subexpressions
|
(only warns if __compat__.collect_all_And_tokens is False)
|
- warn_ungrouped_named_tokens_in_collection - flag to enable warnings when a results
|
name is defined on a containing expression with ungrouped subexpressions that also
|
have results names
|
- warn_name_set_on_empty_Forward - flag to enable warnings whan a Forward is defined
|
with a results name, but has no contents defined
|
- warn_on_multiple_string_args_to_oneof - flag to enable warnings whan oneOf is
|
incorrectly called with multiple str arguments
|
- enable_debug_on_named_expressions - flag to auto-enable debug on all subsequent
|
calls to ParserElement.setName()
|
Fc C s$ g | ] }| d ¡s | d¡r|qS )Zenable_Zwarn_©Ú
|
startswith)Ú.0Únmr r r Ú
|
<listcomp>¼ s
|
|
r c C s dt _dt _dt _dt _d S ©NT)Ú__diag__Ú)warn_multiple_tokens_in_named_alternationÚ)warn_ungrouped_named_tokens_in_collectionÚ warn_name_set_on_empty_ForwardÚ%warn_on_multiple_string_args_to_oneofr r r r Ú_enable_all_warnings¾ s r Ú __version__Ú__versionTime__Ú
|
__author__Ú
|
__compat__r ÚAndÚCaselessKeywordÚCaselessLiteralÚ
|
CharsNotInÚCombineÚDictÚEachÚEmptyÚ
|
FollowedByÚForwardÚ
|
GoToColumnÚGroupÚKeywordÚLineEndÚ LineStartÚLiteralÚ
|
PrecededByÚ
|
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ÚCharÚ 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Úpyparsing_unicodeÚ unicode_setÚconditionAsParseActionÚreé 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©Útr r r Ú<lambda>ÿ ó z_ustr.<locals>.<lambda>N)
|
Ú
|
isinstanceÚunicodeÚstrÚUnicodeEncodeErrorÚencodeÚsysÚgetdefaultencodingrF ÚsetParseActionÚtransformString)ÚobjÚretZ
|
xmlcharrefr r r Ú_ustrì s
|
|
r¨ z6sum len sorted reversed list tuple set any all min maxc c s | ]
|
}|V qd S ©Nr )r Úyr r r Ú <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 )ú&ú;Nr )r Úsr r r r« s z _xml_escape.<locals>.<genexpr>zamp gt lt quot apos)ÚsplitÚzipÚreplace)ÚdataÚ from_symbolsÚ
|
to_symbolsÚfrom_Úto_r r r Ú _xml_escape s
|
r¸ Ú
|
0123456789Z ABCDEFabcdefé\ Ú c c s | ]}|t jkr|V qd S r© )ÚstringÚ
|
whitespace©r Úcr r r r« s
|
c s@ |d k r |nd|rt nt tt fdd}|S )Nz failed user-defined conditionc s t | ||s | |d S r© )Úbool©r¯ Úlr ©Úexc_typeÚfnÚmsgr r Úpa% s z"conditionAsParseAction.<locals>.pa)r@ r> Ú _trim_arityr )rÅ ÚmessageÚfatalrÇ r rà r 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» )ÚlocrÆ ÚpstrÚ parserElementÚargs)ÚselfrÍ rÌ rÆ Úelemr r r Ú__init__0 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Úper r r Ú_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
|
rj )rY Úcolumnrg N)rj rÌ rÍ rY rg ÚAttributeError)rÐ Úanamer r r Ú __getattr__C s z ParseBaseException.__getattr__c C s^ | j r@| jt| j kr d}qDd| j | j| jd
dd¡}nd}d| j|| j| j| jf S )Nz, found end of textz
|
, found %rr¬ z\\ú\r» z%%s%s (at char %d), (line:%d, col:%d))rÍ rÌ Úlenr² rÆ rj rÖ )rÐ Úfoundstrr r r Ú__str__R s $ÿzParseBaseException.__str__c C s t | S r© ©r¨ ©rÐ r r r Ú__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)rg rÖ ÚjoinÚstrip)rÐ Ú markerStringÚline_strÚ line_columnr r r Ú markInputline^ s
|
|
ÿz ParseBaseException.markInputlinec C s d ¡ tt| S )Nzlineno col line)r° ÚdirÚtyperß r r r Ú__dir__h s zParseBaseException.__dir__)r NN)rá ) r r r Ú__doc__rÒ Ú classmethodrÕ rÙ rÝ rà rç rê r r r r r< , s
|
|
|
|
|
c @ s e Zd ZdZedddZdS )r> a:
|
Exception thrown when parse expressions don't match class;
|
supported attributes by name are:
|
- lineno - returns the line number of the exception text
|
- col - returns the column number of the exception text
|
- line - returns the line containing the exception text
|
|
Example::
|
|
try:
|
Word(nums).setName("integer").parseString("ABC")
|
except ParseException as pe:
|
print(pe)
|
print("column: {}".format(pe.col))
|
|
prints::
|
|
Expected integer (at char 0), (line:1, col:1)
|
column: 1
|
|
é c C sp ddl }|dkrt ¡ }g }t| trJ| | j¡ | d| jd d ¡ | d t | j
|
| ¡¡ |dkrf|j | j |d}t }t|| d
D ]Ð\}}|d }|j dd¡} t| tr|jjd krÌq| |krÖq| | ¡ t | }
|
| d
|
|
|
j|
|
j
|
| ¡¡ nP| dk r,t | }
|
| d |
|
j|
|
j
|
¡¡ n&|j} | jd kr@q| d | j¡¡ |d8 }|s qfqd |¡S )ap
|
Method to take an exception and translate the Python internal traceback into a list
|
of the pyparsing expressions that caused the exception to be raised.
|
|
Parameters:
|
|
- exc - exception raised during parsing (need not be a ParseException, in support
|
of Python exceptions that might be raised in a parse action)
|
- depth (default=16) - number of levels back in the stack trace to list expression
|
and function names; if None, the full stack trace names will be listed; if 0, only
|
the failing input line, marker, and exception string will be shown
|
|
Returns a multi-line string listing the ParserElements and/or function names in the
|
exception's stack trace.
|
|
Note: the diagnostic output will include string representations of the expressions
|
that failed to parse. These representations will be more helpful if you use `setName` to
|
give identifiable names to your expressions. Otherwise they will use the default string
|
forms, which may be cryptic to read.
|
|
explain() is only supported under Python 3.
|
r Nú r¬ ú^z{0}: {1})ÚcontextrÐ )Ú parseImplÚ _parseNoCachez {0}.{1} - {2}z{0}.{1})Úwrapperz<module>z{0}Ú
|
)Úinspectr¢ Úgetrecursionlimitr r< Úappendrg rY Úformatré r ÚgetinnerframesÚ __traceback__ÚsetÚ enumerateÚf_localsÚgetrC Úf_codeÚco_nameÚaddr râ ) ÚexcÚdepthrõ r§ ÚcallersÚseenÚiÚffÚfrmÚf_selfÚ self_typeÚcoder r r Úexplain sL
|
|
|
þ
|
ÿ zParseException.explainN)rí )r r r rë Ú staticmethodr r r r r r> k s c @ s e Zd ZdZdS )r@ znuser-throwable exception thrown when inconsistent parse content
|
is found; stops all parsing immediatelyN©r r r rë r r r r r@ È s c @ s e Zd ZdZdS )rB zîjust like :class:`ParseFatalException`, but thrown internally
|
when an :class:`ErrorStop<And._ErrorStop>` ('-' operator) indicates
|
that parsing is to stop immediately because an unbacktrackable
|
syntax error has been found.
|
Nr r r r r rB Í s c @ s e Zd ZdZdd Zdd ZdS )rE ziexception thrown by :class:`ParserElement.validate` if the
|
grammar could be improperly recursive
|
c C s
|
|| _ d S r© ©ÚparseElementTrace©rÐ ÚparseElementListr r r rÒ æ s z"RecursiveGrammarException.__init__c C s
|
d| j S )Nz RecursiveGrammarException: %sr rß r r r rÝ é s z!RecursiveGrammarException.__str__N)r r r rë rÒ rÝ r r r r rE â s c @ s, e Zd Zdd Zdd Zdd Zdd Zd S )
|
Ú_ParseResultsWithOffsetc C s ||f| _ d S r© ©Útup)rÐ Úp1Úp2r r r rÒ í s z _ParseResultsWithOffset.__init__c C s
|
| j | S r© r ©rÐ r r r r Ú __getitem__ï s z#_ParseResultsWithOffset.__getitem__c C s t | jd S ©Nr )Úreprr rß r r r rà ñ s z _ParseResultsWithOffset.__repr__c C s | j d |f| _ d S r r r r r r Ú setOffsetó s z!_ParseResultsWithOffset.setOffsetN)r r r rÒ r rà r r r r r 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-dadOdPZ.dQdR Z/dSdT Z0dUdV Z1dWdX Z2dYdZ Z3e4dbd[d\Z5dS )crA aS Structured parse results, to provide multiple means of access to
|
the parsed data:
|
|
- as a list (``len(results)``)
|
- by list index (``results[0], results[1]``, etc.)
|
- by attribute (``results.<resultsName>`` - see :class:`ParserElement.setResultsName`)
|
|
Example::
|
|
integer = Word(nums)
|
date_str = (integer.setResultsName("year") + '/'
|
+ integer.setResultsName("month") + '/'
|
+ integer.setResultsName("day"))
|
# equivalent form:
|
# date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
|
# parseString returns a ParseResults object
|
result = date_str.parseString("1999/12/31")
|
|
def test(s, fn=repr):
|
print("%s -> %s" % (s, fn(eval(s))))
|
test("list(result)")
|
test("result[0]")
|
test("result['month']")
|
test("result.day")
|
test("'month' in result")
|
test("'minutes' in result")
|
test("result.dump()", str)
|
|
prints::
|
|
list(result) -> ['1999', '/', '12', '/', '31']
|
result[0] -> '1999'
|
result['month'] -> '12'
|
result.day -> '31'
|
'month' in result -> True
|
'minutes' in result -> False
|
result.dump() -> ['1999', '/', '12', '/', '31']
|
- day: 31
|
- month: 12
|
- year: 1999
|
NTc C s" t || r|S t | ¡}d|_|S r )r ÚobjectÚ__new__Ú_ParseResults__doinit)rÓ ÚtoklistÚnameÚasListÚmodalÚretobjr r r r ! s
|
|
|
zParseResults.__new__c
|
C sd | 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*||trtt|jd| |< 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__tokdictr r¨ ré Ú
|
basestringrA r ÚKeyErrorÚ TypeErrorÚ
|
IndexError)rÐ r r! r" r# r r r r rÒ * sB
|
|
|
|
$
|
zParseResults.__init__c C sP t |ttfr| j| S || jkr4| j| d d S tdd | j| D S d S )Nr r c S s g | ] }|d qS ©r r ©r Úvr r r r X s z,ParseResults.__getitem__.<locals>.<listcomp>)r r Úslicer+ r' r. rA r r r r r Q 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. rþ r* r r6 r+ rA Úwkrefr& )rÐ Úkr5 r Úsubr r r Ú __setitem__Z 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 r r6 rÛ r+ r* ÚrangeÚindicesÚreverser. Úitemsrü r )
|
rÐ r ÚmylenÚremovedr! Ú occurrencesÚjr8 ÚvalueÚpositionr r r Ú __delitem__g s
|
|
zParseResults.__delitem__c C s
|
|| j kS r© )r. )rÐ r8 r r r Ú __contains__| s zParseResults.__contains__c C s
|
t | jS r© )rÛ r+ rß r r r Ú__len__ s zParseResults.__len__c C s
|
| j S r© ©r+ rß r r r Ú__bool__ s zParseResults.__bool__c C s
|
t | jS r© ©Úiterr+ rß r r r Ú__iter__ s zParseResults.__iter__c C s t | jd d d
S ©Nr rK rß r r r Ú __reversed__ s zParseResults.__reversed__c C s$ t | jdr| j ¡ S t| jS d S )NÚiterkeys)Úhasattrr. rP rL rß r r r Ú _iterkeys s
|
zParseResults._iterkeysc s fdd ¡ D S )Nc 3 s | ]} | V qd S r© r ©r r8 rß r r r« s z+ParseResults._itervalues.<locals>.<genexpr>©rR rß r rß r Ú _itervalues s zParseResults._itervaluesc s fdd ¡ D S )Nc 3 s | ]}| | fV qd S r© r rS rß r r r« s z*ParseResults._iteritems.<locals>.<genexpr>rT rß r rß r Ú
|
_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* rP rß r r r Ú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ß r r r Ú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ß r r r 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.)rÀ r. rß r r r Ú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= ``last``).
|
Supports both ``list`` and ``dict`` semantics for ``pop()``. If
|
passed no argument or an integer argument, it will use ``list``
|
semantics and pop tokens from the list of parsed tokens. If passed
|
a non-integer argument (most likely a string), it will use ``dict``
|
semantics and pop the corresponding value from any defined results
|
names. A second default return value argument is supported, just as in
|
``dict.pop()``.
|
|
Example::
|
|
def remove_first(tokens):
|
tokens.pop(0)
|
print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
|
print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
|
|
label = Word(alphas)
|
patt = label("LABEL") + OneOrMore(Word(nums))
|
print(patt.parseString("AAB 123 321").dump())
|
|
# Use pop() in a parse action to remove named result (note that corresponding value is not
|
# removed from list form of results)
|
def remove_LABEL(tokens):
|
tokens.pop("LABEL")
|
return tokens
|
patt.addParseAction(remove_LABEL)
|
print(patt.parseString("AAB 123 321").dump())
|
|
prints::
|
|
['AAB', '123', '321']
|
- LABEL: AAB
|
|
['AAB', '123', '321']
|
r Údefaultr z-pop() got an unexpected keyword argument '%s'r¬ N)r? r1 r r rÛ )rÐ rÏ Úkwargsr8 r5 Úindexr§ Ú defaultvaluer r r Úpop½ s" %
|
ÿ
|
þzParseResults.popc C s || kr| | S |S dS )a[
|
Returns named result matching the given key, or if there is no
|
such name, then returns the given ``defaultValue`` or ``None`` if no
|
``defaultValue`` is specified.
|
|
Similar to ``dict.get()``.
|
|
Example::
|
|
integer = Word(nums)
|
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
|
result = date_str.parseString("1999/12/31")
|
print(result.get("year")) # -> '1999'
|
print(result.get("hour", "not specified")) # -> 'not specified'
|
print(result.get("hour")) # -> None
|
Nr )rÐ ÚkeyÚ defaultValuer r r rþ ô 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 ``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! rB r8 rD rE r r r rc 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+ r÷ )rÐ Úitemr r r r÷ s zParseResults.appendc C s& t |tr| |¡ 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 rA Ú__iadd__r+ Úextend)rÐ Úitemseqr r r rg / s
|
zParseResults.extendc C s | j dd
= | j ¡ dS )z7
|
Clear all elements and results names.
|
N)r+ r. Úclearrß r r r ri B s zParseResults.clearc C s& z
|
| | W S t k
|
r Y dS X d S rË )r0 ©rÐ r! r r r rÙ I s
|
zParseResults.__getattr__c C s | ¡ }||7 }|S r© ©Úcopy)rÐ Úotherr§ r r r Ú__add__O 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 r )Úa)Úoffsetr r r W r z'ParseResults.__iadd__.<locals>.<lambda>c s4 g | ],\}}|D ] }|t |d |d fqqS ©r r¬ )r ©r r8 Úvlistr5 )Ú addoffsetr r r Y s ÿz)ParseResults.__iadd__.<locals>.<listcomp>r )
|
r. rÛ r+ r? r rA r7 r& r' Úupdate)rÐ rm Ú
|
otheritemsÚotherdictitemsr8 r5 r )rt rp r rf T s
|
|
|
ÿ zParseResults.__iadd__c C s& t |tr|dkr| ¡ S || S d S r )r r rl ©rÐ rm r r r Ú__radd__d s zParseResults.__radd__c C s dt | jt | jf S )Nz(%s, %s))r r+ r. rß r r r rà l s zParseResults.__repr__c C s dd dd | jD ¡ d S )Nú[ú, c s s( | ] }t |trt|nt|V qd S r© )r rA r¨ r ©r r r r r r« p s z'ParseResults.__str__.<locals>.<genexpr>ú])râ r+ rß r r r rÝ o s zParseResults.__str__r» c C sL g }| j D ]<}|r |r | |¡ t|tr8|| ¡ 7 }q
|
| t|¡ q
|
|S r© )r+ r÷ r rA Ú _asStringListr¨ )rÐ ÚsepÚoutre r r r r~ r s
|
|
|
zParseResults._asStringListc C s dd | j D S )ax
|
Returns the parse results as a nested list of matching tokens, all converted to strings.
|
|
Example::
|
|
patt = OneOrMore(Word(alphas))
|
result = patt.parseString("sldkj lsdkj sldkj")
|
# even though the result prints in string-like form, it is actually a pyparsing ParseResults
|
print(type(result), result) # -> <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 r )r rA r" )r Úresr r r r s z'ParseResults.asList.<locals>.<listcomp>rI rß r r r 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 r r r4 ©ÚtoItemr r r ¬ s z7ParseResults.asDict.<locals>.toItem.<locals>.<listcomp>)r rA r[ ÚasDict©r¦ r r r r § s
|
|
z#ParseResults.asDict.<locals>.toItemc 3 s | ]\}}| |fV qd S r© r ©r r8 r5 r r r r« ° s z&ParseResults.asDict.<locals>.<genexpr>)ÚPY_3r? rZ r- )rÐ Úitem_fnr r r r s
|
zParseResults.asDictc C s< t | j}t| j ¡ |_| j|_|j | j¡ | j|_|S )zG
|
Returns a new copy of a :class:`ParseResults` object.
|
) rA r+ r- r. r? r& r' ru r% ©rÐ r§ r r r rl ² 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.
|
rô c s s( | ] \}}|D ]}|d |fV qqdS ©r¬ Nr rr r r r r« Ã s ÿz%ParseResults.asXML.<locals>.<genexpr>ú r» NÚITEMú<ú>ú</) r- r. r? r% rü r+ r rA ÚasXMLr¸ r¨ râ )rÐ ÚdoctagÚnamedItemsOnlyÚindentÚ formattedÚnlr Ú
|
namedItemsÚnextLevelIndentÚselfTagr r ÚresTagÚ xmlBodyTextr r r r ½ s^
|
|
ý
|
|
ý
|
þzParseResults.asXMLc C s: | j ¡ D ]*\}}|D ] \}}||kr| S qq
|
d S r© )r. r? )rÐ r9 r8 rs r5 rÌ r r r Ú__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 r ) r% r& Ú_ParseResults__lookuprÛ r. ÚnextrL rY rW )rÐ Úparr r r ÚgetName s
|
ÿ þzParseResults.getNamer c C sv g }d}|r$| |t| ¡ ¡ n
|
| d¡ |rl| ¡ rÒtdd | ¡ D }|D ]x\}} |rl| |¡ | d|d| |f ¡ t| trÀ| r°| | j||||d d¡ qÎ| t| ¡ qV| t | ¡ qVnt
|
d d | D rl| } t | D ]x\}
|
} t| tr@| d
|
|d| |
|
|d|d | j||||d df ¡ qò| d
|
|d| |
|
|d|d t| f ¡ qòd |¡S ) aF
|
Diagnostic method for listing out the contents of
|
a :class:`ParseResults`. Accepts an optional ``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
|
rô r» c s s | ]\}}t ||fV qd S r© )r r r r r r« G s z$ParseResults.dump.<locals>.<genexpr>z
|
%s%s- %s: r r¬ )r ÚfullÚ include_listÚ_depthc s s | ]}t |tV qd S r© )r rA )r Úvvr r r r« S s z
|
%s%s[%d]:
|
%s%s%s) r÷ r¨ r" r[ Úsortedr? r rA Údumpr Úanyrü râ ) rÐ r r r¡ r¢ r ÚNLr? r8 r5 r r£ r r r r¥ ) sP
|
|
|
|
ýû
|
|
|
û
|
zParseResults.dumpc O s t j | ¡ f|| dS )a#
|
Pretty-printer for parsed results as a list, using the
|
`pprint <https://docs.python.org/3/library/pprint.html>`_ module.
|
Accepts additional positional or keyword args as defined for
|
`pprint.pprint <https://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] r r r r¨ j s zParseResults.pprintc C s. | j | j ¡ | jd k r | ¡ p d | j| jffS r© )r+ r. rl r& r' r% rß r r r Ú __getstate__ s ýÿzParseResults.__getstate__c C sN |d | _ |d \| _}}| _i | _| j |¡ |d k rDt|| _nd | _d S r; )r+ r. r% r' ru r7 r& )rÐ Ústater Ú inAccumNamesr r r Ú __setstate__ s
|
zParseResults.__setstate__c C s | j | j| j| jfS r© )r+ r% r( r) rß r r r Ú__getnewargs__ s zParseResults.__getnewargs__c C s t t| t| ¡ S r© )rè ré r* rW rß r r r rê s zParseResults.__dir__c C sr dd }| g }| ¡ D ]>\}}t|tr>|| j||d7 }q|| |g|||d7 }q|dk rn| |g|d}|S )zã
|
Helper classmethod to construct a ParseResults from a dict, preserving the
|
name-value relations as results names. If an optional 'name' argument is
|
given, a nested ParseResults will be returned
|
c S sH z t | W n tk
|
r" Y dS X tr8t| ttf S t| t S d S ©NF)rL Ú Exceptionr r r Úbytesr/ r
r r r Ú is_iterable¤ s z+ParseResults.from_dict.<locals>.is_iterable©r! )r! r" N)r? r r Ú from_dict)rÓ rm r! r² r§ r8 r5 r r r r´ s
|
zParseResults.from_dict)NNTT)N)r» )NFr» T)r» TTr )N)6r r r rë r r rÒ r r: rF rG rH rJ Ú __nonzero__rM rO rR rU rV r rW rY r? rP rX rZ r[ r` rþ rc r÷ rg ri rÙ rn rf ry rà rÝ r~ r" r rl r r r r¥ r¨ rª r r® rê rì r´ r r r r rA ö sl *
|
' 7
|
|
$
|
=(
|
A
|
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
|
:class:`ParserElement.parseString` for more
|
information on parsing strings containing ``<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¬ rô )rÛ Úrfind)rÌ Ústrgr¯ r r r rY » 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 :class:`ParserElement.parseString`
|
for more information on parsing strings containing ``<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 r¬ )Úcount)rÌ r· r r r rj É 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.
|
rô r r¬ N)r¶ Úfind)rÌ r· ÚlastCRÚnextCRr r r rg Õ s
|
c C s8 t dt| d t| dt|| t|| f d S )NzMatch z at loc z(%d,%d))Úprintr¨ rj rY )ÚinstringrÌ Úexprr r r Ú_defaultStartDebugActionß s r¿ c C s$ t dt| d t| ¡ d S )NzMatched z -> )r¼ r¨ r r" )r½ ÚstartlocÚendlocr¾ Útoksr r r Ú_defaultSuccessDebugActionâ s rà c C s t dt| d S )NzException raised:)r¼ r¨ )r½ rÌ r¾ r r r r Ú _defaultExceptionDebugActionå s rÄ c G s dS )zG'Do-nothing' debug action, to suppress debugging output during parsing.Nr )rÏ r r r rq è s r 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© r rÁ )Úfuncr r r r z _trim_arity.<locals>.<lambda>r Fr )r é c S s8 t dkr dnd}tj| | d d| }|d d
gS )N)r rÆ r éýÿÿÿéþÿÿÿr¬ ©Úlimitr )Úsystem_versionÚ tracebackÚ extract_stack)rÊ rp Ú frame_summaryr r r rÍ s z"_trim_arity.<locals>.extract_stackc S s$ t j| |d}|d }|d d
gS )NrÉ r r )rÌ Ú
|
extract_tb)ÚtbrÊ ÚframesrÎ r r r rÏ s z _trim_arity.<locals>.extract_tbé rÉ r r¬ c sº z"| d d
}dd< |W S t k
|
r² d r> nNz.t ¡ d } |ddd d d
ksj W 5 z~W n tk
|
r Y nX X d kr¬d d7 < Y q Y q X q d S )Nr Tr r rÉ r¬ )r1 Ú NameErrorr¢ Úexc_info)rÏ r§ rÐ ©rÏ Ú
|
foundArityrÅ rÊ ÚmaxargsÚpa_call_line_synthr r ró ! s& z _trim_arity.<locals>.wrapperz<parse action>r Ú __class__)r )r ) ÚsingleArgBuiltinsrË rÌ rÍ rÏ Úgetattrr r° r )rÅ r× rÍ Ú LINE_DIFFÚ this_lineró Ú func_namer rÕ r rÈ s,
|
|
ÿrÈ c @ s° e Zd ZdZdZdZedd Zedd Ze dd Z
|
dd
|
d Z d d Z dd Z dddZdddZdddZdd Zdd Zdd Zd d Zd d Zd!d" Zdd#d$Zd%d& Zdd'd(Zd)d* Zd+d, ZG d-d. d.e Z e d/k røG d0d1 d1e Z nG d2d1 d1e Z i Z e! Z"d3d3gZ#dd4d5Z$eZ%ed6d7 Z&dZ'edd9d:Z(dd;d<Z)e*dfd=d>Z+d?d@ Z,e*fdAdBZ-e*dfdCdDZ.dEdF Z/dGdH Z0dIdJ Z1dKdL Z2dMdN Z3dOdP Z4dQdR Z5dSdT Z6dUdV Z7dWdX Z8dYdZ Z9d[d\ Z:d]d^ Z;d_d` Z<dadb Z=ddcddZ>dedf Z?dgdh Z@didj ZAdkdl ZBdmdn ZCdodp ZDddqdrZEdsdt ZFdudv ZGdwdx ZHdydz ZIdd{d|ZJdd}d~ZKdd ZLdd ZMdd ZNd
d ZOdd ZPdddZQdddZRd/S )rC 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)rC ÚDEFAULT_WHITE_CHARS©Úcharsr r r ÚsetDefaultWhitespaceCharsL s z'ParserElement.setDefaultWhitespaceCharsc C s
|
| t _dS )ah
|
Set class to be used for inclusion of string literals into a parser.
|
|
Example::
|
|
# default literal class used is Literal
|
integer = Word(nums)
|
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
|
date_str.parseString("1999/12/31") # -> ['1999', '/', '12', '/', '31']
|
|
|
# change to Suppress
|
ParserElement.inlineLiteralsUsing(Suppress)
|
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
|
date_str.parseString("1999/12/31") # -> ['1999', '12', '31']
|
N)rC Ú_literalStringClass©rÓ r r r ÚinlineLiteralsUsing\ s z!ParserElement.inlineLiteralsUsingc C s |j r|j }q |S r© )Útb_next)rÓ rÐ r r r Ú_trim_tracebackr s z ParserElement._trim_tracebackc C s t | _d | _d | _d | _|| _d| _ttj | _
|
d| _ d| _ d| _ t | _d| _d| _d| _d| _d| _d| _d | _d| _d| _d S )NTFr» )NNN)r* Ú parseActionÚ
|
failActionÚstrReprÚ resultsNameÚ
|
saveAsListÚskipWhitespacerû rC rß Ú
|
whiteCharsÚcopyDefaultWhiteCharsÚmayReturnEmptyÚkeepTabsÚ ignoreExprsÚdebugÚ streamlinedÚ mayIndexErrorÚerrmsgÚ modalResultsÚ debugActionsr Ú callPreparseÚ callDuringTry)rÐ Úsavelistr r r rÒ x s( zParserElement.__init__c C s< t | ¡}| jdd
|_| jdd
|_| jr8tj|_|S )a/
|
Make a copy of this :class:`ParserElement`. Useful for defining
|
different parse actions for the same parsing pattern, using copies of
|
the original parse element.
|
|
Example::
|
|
integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
|
integerK = integer.copy().addParseAction(lambda toks: toks[0] * 1024) + Suppress("K")
|
integerM = integer.copy().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
|
|
print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
|
|
prints::
|
|
[5120, 100, 655360, 268435456]
|
|
Equivalent form of ``expr.copy()`` is just ``expr()``::
|
|
integerM = integer().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")
|
N)rl rè rò rï rC rß rî )rÐ Úcpyr r r rl s
|
zParserElement.copyc C s$ || _ d| j | _tjr | ¡ | S )a_
|
Define name for this expression, makes debugging and exception messages clearer.
|
|
Example::
|
|
Word(nums).parseString("ABC") # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
|
Word(nums).setName("integer").parseString("ABC") # -> Exception: Expected integer (at char 0), (line:1, col:1)
|
ú Expected )r! rö r Ú!enable_debug_on_named_expressionsÚsetDebugrj r r r ÚsetName¬ s
|
zParserElement.setNamec C s | ||¡S )aO
|
Define name for referencing matching tokens as a nested attribute
|
of the returned parse results.
|
NOTE: this returns a *copy* of the original :class:`ParserElement` object;
|
this is so that the client can define a basic element, such as an
|
integer, and reference it in multiple places with different names.
|
|
You can also set results names using the abbreviated syntax,
|
``expr("name")`` in place of ``expr.setResultsName("name")``
|
- see :class:`__call__`.
|
|
Example::
|
|
date_str = (integer.setResultsName("year") + '/'
|
+ integer.setResultsName("month") + '/'
|
+ integer.setResultsName("day"))
|
|
# equivalent form:
|
date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
|
)Ú_setResultsName©rÐ r! ÚlistAllMatchesr r r ÚsetResultsName» s z ParserElement.setResultsNamec C s4 | ¡ }| d¡r"|d d
}d}||_| |_|S )NÚ*r T)rl Úendswithrë r÷ )rÐ r! r Únewselfr r r r Ò 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 ``breakFlag`` to True to enable, False to
|
disable.
|
Tc s dd l }| ¡ | |||S r )ÚpdbÚ set_trace)r½ rÌ Ú doActionsÚ callPreParser ©Ú _parseMethodr r Úbreakerâ s z'ParserElement.setBreak.<locals>.breakerÚ_originalParseMethod)TT)Ú_parser rQ )rÐ Ú breakFlagr r r r ÚsetBreakÛ s
|
zParserElement.setBreakc O sV t |dgkrg | _n<tdd |D s0tdt 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 ``fn(s, loc, toks)`` ,
|
``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where:
|
|
- s = the original string being parsed (see note below)
|
- loc = the location of the matching substring
|
- toks = a list of the matched tokens, packaged as a :class:`ParseResults` object
|
|
If the functions in fns modify the tokens, they can return them as the return
|
value from fn, and the modified list of tokens will replace the original.
|
Otherwise, fn does not need to return any value.
|
|
If None is passed as the parse action, all previously added parse actions for this
|
expression are cleared.
|
|
Optional keyword arguments:
|
- callDuringTry = (default= ``False``) indicate if parse action should be run during lookaheads and alternate testing
|
|
Note: the default parsing behavior is to expand tabs in the input string
|
before starting the parsing process. See :class:`parseString for more
|
information on parsing strings containing ``<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]
|
Nc s s | ]}t |V qd S r© )Úcallable)r rÅ r r r r« s z/ParserElement.setParseAction.<locals>.<genexpr>z parse actions must be callablerú F)r* rè Úallr1 ÚmaprÈ rþ rú ©rÐ Úfnsr] r r r 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 :class:`setParseAction`.
|
|
See examples in :class:`copy`.
|
rú F)rè r* r rÈ rú rþ r r r r ÚaddParseAction s z ParserElement.addParseActionc
|
O sF |D ](}| j t|| d¡| dd¡d¡ q| jp>| dd¡| _| S )a¼ Add a boolean predicate function to expression's list of parse actions. See
|
:class:`setParseAction` for function call signatures. Unlike ``setParseAction``,
|
functions passed to ``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)
|
rÉ rÊ F)rÉ rÊ rú )rè r÷ r rþ rú )rÐ r r] rÅ r r r Ú 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
|
``fn(s, loc, expr, err)`` where:
|
- s = string being parsed
|
- loc = location where expression match was attempted and failed
|
- expr = the parse expression that failed
|
- err = the exception thrown
|
The function returns no value. It may throw :class:`ParseFatalException`
|
if it is desired to stop parsing immediately.)ré ©rÐ rÅ r r r Ú setFailActionB 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Ð r½ rÌ Ú
|
exprsFoundÚeÚdummyr r r Ú_skipIgnorablesO s
|
|
|
z ParserElement._skipIgnorablesc C sH | j r| ||¡}| jrD| j}t|}||k rD|| |krD|d7 }q&|S ©Nr¬ )rò r rí rî rÛ )rÐ r½ rÌ ÚwtÚinstrlenr r r ÚpreParse\ s
|
zParserElement.preParsec C s |g fS r© r ©rÐ r½ rÌ r
|
r r r rñ h s zParserElement.parseImplc C s |S r© r ©rÐ r½ rÌ Ú tokenlistr r r Ú postParsek s zParserElement.postParsec C s d\}}}| j }|s | jr"| j| r8| j| ||| z|rR| jrR| ||¡} n|} | }
|
| jsl| t|kr®z| || |¡\}} W qÀ tk
|
rª t |t|| j
|
| Y qÀX n| || |¡\}} W n\ t k
|
r } z<| j| rô| j| ||
|
| | | jr | ||
|
| | ¡ W 5 d } ~ X Y nX n|r>| jr>| ||¡} n|} | }
|
| js\| t|kr z| || |¡\}} W n* tk
|
r t |t|| j
|
| Y nX n| || |¡\}} | ||| ¡} t | | j| j| jd} | jr`|sì| jr`|rÐz| jD ]}z|||
|
| } W n6 tk
|
rD } zt d}||_|W 5 d }~X Y nX | d k rú| | k rút | | j| jovt| t tf| jd} qúW nF t k
|
rÌ } z&| j| rº| j| ||
|
| | W 5 d } ~ X Y nX n| jD ]}z|||
|
| } W n6 tk
|
r } zt d}||_|W 5 d }~X Y nX | d k rÖ| | k rÖt | | j| joRt| t tf| jd} qÖ|r| j| r| j| ||
|
|| | || fS )N)r r¬ r )r" r# z exception raised in parse action)ró ré rø rù r$ rõ rÛ rñ r2 r> rö r° r( rA rë rì r÷ rè rú Ú __cause__r r* )rÐ r½ rÌ r
|
r ÚTRYÚMATCHÚFAILÚ debuggingÚprelocÚ tokensStartÚtokensÚerrÚ retTokensrÅ Úparse_action_excr r r r rò o s
|
|
|
|
|
ý
|
ý
|
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Ð r½ rÌ r r r ÚtryParseÆ s zParserElement.tryParsec C s4 z| ||¡ W n ttfk
|
r* Y dS X dS d S )NFT)r6 r> r2 r5 r r r Ú 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Ð ra ©ÚcacheÚ not_in_cacher r rþ Ù s z3ParserElement._UnboundedCache.__init__.<locals>.getc s | |< d S r© r ©rÐ ra rD ©r; r r rû Ü s z3ParserElement._UnboundedCache.__init__.<locals>.setc s ¡ d S r© ©ri rß r> r r ri ß s z5ParserElement._UnboundedCache.__init__.<locals>.clearc s t S r© ©rÛ rß r> r r Ú cache_lenâ s z9ParserElement._UnboundedCache.__init__.<locals>.cache_len)r r< ÚtypesÚ
|
MethodTyperþ rû ri rH )rÐ rþ rû ri rA r r: r rÒ Õ s z&ParserElement._UnboundedCache.__init__N©r r r rÒ r r r r Ú_UnboundedCacheÔ s rE 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© r8 r9 r: r r rþ ñ s ú.ParserElement._FifoCache.__init__.<locals>.getc s> | |< t kr:z d¡ W q tk
|
r6 Y qX qd S r¯ )rÛ Úpopitemr0 r= )r; Úsizer r rû ô s ú.ParserElement._FifoCache.__init__.<locals>.setc s ¡ d S r© r? rß r> r r ri ü s ú0ParserElement._FifoCache.__init__.<locals>.clearc s t S r© r@ rß r> r r rA ÿ s ú4ParserElement._FifoCache.__init__.<locals>.cache_len) r r< Ú _OrderedDictrB rC rþ rû ri rH ©rÐ rI rþ rû ri rA r )r; r< rI r rÒ ì s ú!ParserElement._FifoCache.__init__NrD r r r r Ú
|
_FifoCacheë s rP c @ s e Zd Zdd ZdS )rF c s t | _i t g ¡ fdd} fdd} fdd} fdd}t || ¡| _t || ¡| _t || ¡| _t || ¡| _ d S ) Nc s |¡S r© r8 r9 r: r r rþ s rG c s4 | |< t kr& ¡ d ¡ q |¡ d S r© )rÛ r` Úpopleftr÷ r= )r; Úkey_fiforI r r rû s rJ c s ¡ ¡ d S r© r? rß )r; rR r r ri s rK c s t S r© r@ rß r> r r rA s rL )
|
r r< Ú collectionsÚdequerB rC rþ rû ri rH rN r )r; rR r< rI r rÒ s rO NrD r r r r rP 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 )Nrq r¬ r )rC Úpackrat_cache_lockÚ packrat_cacherþ r< Úpackrat_cache_statsrò r< rû rÙ rÏ rl r r° ) rÐ r½ rÌ r
|
r ÚHITÚMISSÚlookupr; rD rÔ r r r Ú _parseCache+ s$
|
|
|
zParserElement._parseCachec C s( t j ¡ dgtt j t jd d
< d S r )rC rV ri rÛ rW r r r r Ú
|
resetCacheD 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= ``128``) - if an integer value is provided
|
will limit the size of the packrat cache; if None is passed, then
|
the cache size will be unbounded; if 0 is passed, the cache will
|
be effectively disabled.
|
|
This speedup may break existing programs that use parse actions that
|
have side-effects. For this reason, packrat parsing is disabled when
|
you first import pyparsing. To activate the packrat feature, your
|
program must call the class method :class:`ParserElement.enablePackrat`.
|
For best results, call ``enablePackrat()`` immediately after
|
importing pyparsing.
|
|
Example::
|
|
from pip._vendor import pyparsing
|
pyparsing.ParserElement.enablePackrat()
|
TN)rC Ú_packratEnabledrE rV rP r[ r )Úcache_size_limitr r r Ú enablePackratJ s zParserElement.enablePackratc
|
C sÌ t ¡ | js| ¡ | jD ] }| ¡ q | js8| ¡ }z<| |d¡\}}|rr| ||¡}t t
|
}| ||¡ W nN t k
|
r } z0t j r n"t |dddk r®| |j¡|_|W 5 d}~X Y nX |S dS )aû
|
Execute the parse expression with the given string.
|
This is the main interface to the client code, once the complete
|
expression has been built.
|
|
Returns the parsed data as a :class:`ParseResults` object, which may be
|
accessed as a list, or as a dict or object with attributes if the given parser
|
includes results names.
|
|
If you want the grammar to require that the entire input string be
|
successfully parsed, then set ``parseAll`` to True (equivalent to ending
|
the grammar with ``StringEnd()``).
|
|
Note: ``parseString`` implicitly calls ``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 ``loc`` argument to index into the
|
string being parsed, you can ensure you have a consistent view of the input
|
string by:
|
|
- calling ``parseWithTabs`` on your grammar before calling ``parseString``
|
(see :class:`parseWithTabs`)
|
- define your parse action using the full ``(s, loc, toks)`` signature, and
|
reference the input string using the parse action's ``s`` argument
|
- explictly expand the tabs in your input string before calling
|
``parseString``
|
|
Example::
|
|
Word('a').parseString('aaaaabaaa') # -> ['aaaaa']
|
Word('a').parseString('aaaaabaaa', parseAll=True) # -> Exception: Expected end of text
|
r rú N)rC r\ rô Ú
|
streamlinerò rñ Ú
|
expandtabsr r$ r+ rH r< Úverbose_stacktracerÛ rç rú )rÐ r½ ÚparseAllr rÌ r0 Úser r r r Ú parseStringm s( !
|
|
zParserElement.parseStringc
|
c sV | 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 nT t k
|
rP } z4t j r n$t|dddk r<| |j¡|_|W 5 d}~X Y nX dS )aq
|
Scan the input string for expression matches. Each match will return the
|
matching tokens, start location, and end location. May be called with optional
|
``maxMatches`` argument, to clip scanning after 'n' matches are found. If
|
``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 :class:`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¬ rú N)rô ra rò rñ r¨ rb rÛ r$ r rC r\ r> r< rc rÛ rç rú )rÐ r½ Ú
|
maxMatchesÚoverlapr r# rÌ Ú
|
preparseFnÚparseFnÚmatchesr. ÚnextLocr0 Únextlocr r r r Ú
|
scanString§ sF
|
|
|
|
|
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ø } z0t j rÆ n"t|dddk rä| |j¡|_|W 5 d}~X Y nX dS )a[
|
Extension to :class:`scanString`, to modify matching text with modified tokens that may
|
be returned from a parse action. To use ``transformString``, define a grammar and
|
attach a parse action to it that modifies the returned token list.
|
Invoking ``transformString()`` on a target string will then scan for matches,
|
and replace the matched text patterns according to the logic in the parse
|
action. ``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 r r ©r Úor r r r s z1ParserElement.transformString.<locals>.<listcomp>r» rú )rñ ro r÷ r rA r" r* râ r r¨ Ú_flattenr< rC rc rÛ rç rú )rÐ r½ r ÚlastEr r¯ r r r r r r¥ ñ s,
|
|
|
|
z ParserElement.transformStringc
|
C sp z t dd | ||¡D W S tk
|
rj } z0tjr8 n"t|dddk rV| |j¡|_|W 5 d}~X Y nX dS )a
|
Another extension to :class:`scanString`, simplifying the access to the tokens found
|
to match the given parse expression. May be called with optional
|
``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 r r )r r r¯ r r r r r 7 s z.ParserElement.searchString.<locals>.<listcomp>rú N)rA ro r< rC rc rÛ rç rú )rÐ r½ rh r r r r Ú searchString! s zParserElement.searchStringc c sT d}d}| j ||dD ]*\}}}|||
V |r<|d V |}q||d
V dS )aR
|
Generator method to split a string using the given expression as a separator.
|
May be called with optional ``maxsplit`` argument, to limit the number of splits;
|
and the optional ``includeSeparators`` argument (default= ``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 )rh N)ro ) rÐ r½ ÚmaxsplitÚincludeSeparatorsÚsplitsÚlastr r¯ r r r r r° A s
|
zParserElement.splitc C sV |t krt| S t|tr$| |¡}t|tsJtjdt| t dd dS t
|
| |gS )a[
|
Implementation of + operator - returns :class:`And`. Adding strings to a ParserElement
|
converts them to :class:`Literal`s by default.
|
|
Example::
|
|
greet = Word(alphas) + "," + Word(alphas) + "!"
|
hello = "Hello, World!"
|
print (hello, "->", greet.parseString(hello))
|
|
prints::
|
|
Hello, World! -> ['Hello', ',', 'World', '!']
|
|
``...`` may be used as a parse expression as a short form of :class:`SkipTo`.
|
|
Literal('start') + ... + Literal('end')
|
|
is equivalent to:
|
|
Literal('start') + SkipTo('end')("_skipped*") + Literal('end')
|
|
Note that the skipped text is returned with '_skipped' as a results name,
|
and to support having multiple skips in the same parser, the value returned is
|
a list of all skipped text.
|
ú4Cannot combine element of type %s with ParserElementr ©Ú
|
stacklevelN) ÚEllipsisÚ _PendingSkipr r/ rã rC ÚwarningsÚwarnré Ú SyntaxWarningr$ rx r r r rn Z s
|
|
|
ÿzParserElement.__add__c C sZ |t krt| d| S t|tr,| |¡}t|tsRtjdt| t dd dS || S )z`
|
Implementation of + operator when left operand is not a :class:`ParserElement`
|
ú _skipped*ry r rz N)
|
r| rG r r/ rã rC r~ r ré r rx r r r ry s
|
|
|
ÿzParserElement.__radd__c C sJ t |tr| |¡}t |ts:tjdt| tdd dS | t ¡ | S )zT
|
Implementation of - operator, returns :class:`And` with error stop
|
ry r rz N)
|
r r/ rã rC r~ r ré r r$ Ú
|
_ErrorStoprx r r r Ú__sub__ s
|
|
|
ÿzParserElement.__sub__c C sB t |tr| |¡}t |ts:tjdt| tdd dS || S )z`
|
Implementation of - operator when left operand is not a :class:`ParserElement`
|
ry r rz N©r r/ rã rC r~ r ré r rx r r r Ú__rsub__ s
|
|
|
ÿzParserElement.__rsub__c s |t krd}n8t|trF|dd
t fkrFd|dd
d dd
}t|tr\|d }}nüt|trJtdd |D }|d
|
dd
}|d dkr¢d|d f}t|d trú|d dkrú|d dkrÐtS |d dkrätS |d t S nNt|d tr,t|d tr,|\}}||8 }n td t|d t|d ntd t||dk rjtd |dk r|td|| krdkr n ntd|rô fdd |rê|dkrÒ | }nt g| | }n |}n |dkr}nt g| }|S )aø
|
Implementation of * operator, allows use of ``expr * 3`` in place of
|
``expr + expr + expr``. Expressions may also me multiplied by a 2-integer
|
tuple, similar to ``{min, max}`` multipliers in regular expressions. Tuples
|
may also include ``None`` as in:
|
- ``expr*(n, None)`` or ``expr*(n, )`` is equivalent
|
to ``expr*n + ZeroOrMore(expr)``
|
(read as "at least n instances of ``expr``")
|
- ``expr*(None, n)`` is equivalent to ``expr*(0, n)``
|
(read as "0 to n instances of ``expr``")
|
- ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)``
|
- ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)``
|
|
Note that ``expr*(None, n)`` does not raise an exception if
|
more than n exprs exist in the input stream; that is,
|
``expr*(None, n)`` does not enforce a maximum number of expr
|
occurrences. If this behavior is desired, then write
|
``expr*(None, n) + ~expr``
|
)r NNr¬ r3 r© r r c s s | ]}|t k r|nd V qd S r© )r| rp r r r r« Ã s z(ParserElement.__mul__.<locals>.<genexpr>©NNz8cannot multiply 'ParserElement' and ('%s', '%s') objectsz0cannot multiply 'ParserElement' and '%s' objectsz/cannot multiply ParserElement by negative valuez@second tuple value must be greater or equal to first tuple valuez,cannot multiply ParserElement by 0 or (0, 0)c s( | dkr t | d S t S d S r! )r: ©Ún©ÚmakeOptionalListrÐ r r r Þ s z/ParserElement.__mul__.<locals>.makeOptionalList)
|
r| r Útupler rQ r8 r1 ré Ú
|
ValueErrorr$ )rÐ rm Ú minElementsÚ optElementsr§ r r r Ú__mul__§ sN
|
|
|
|
|
|
|
zParserElement.__mul__c C s
|
| |¡S r© )r rx r r r Ú__rmul__ñ s zParserElement.__rmul__c C sZ |t krt| ddS t|tr(| |¡}t|tsNtjdt| t dd dS t
|
| |gS )zL
|
Implementation of | operator - returns :class:`MatchFirst`
|
T)Ú must_skipry r rz N) r| r} r r/ rã rC r~ r ré r r5 rx r r r Ú__or__ô s
|
|
|
ÿzParserElement.__or__c C sB t |tr| |¡}t |ts:tjdt| tdd dS || B S )z`
|
Implementation of | operator when left operand is not a :class:`ParserElement`
|
ry r rz Nr rx r r r Ú__ror__ s
|
|
|
ÿzParserElement.__ror__c C sF t |tr| |¡}t |ts:tjdt| tdd dS t| |gS )zD
|
Implementation of ^ operator - returns :class:`Or`
|
ry r rz N) r r/ rã rC r~ r ré r r; rx r r r Ú__xor__ s
|
|
|
ÿzParserElement.__xor__c C sB t |tr| |¡}t |ts:tjdt| tdd dS || A S )z`
|
Implementation of ^ operator when left operand is not a :class:`ParserElement`
|
ry r rz Nr rx r r r Ú__rxor__ s
|
|
|
ÿzParserElement.__rxor__c C sF t |tr| |¡}t |ts:tjdt| tdd dS t| |gS )zF
|
Implementation of & operator - returns :class:`Each`
|
ry r rz N) r r/ rã rC r~ r ré r r* rx r r r Ú__and__' s
|
|
|
ÿzParserElement.__and__c C sB t |tr| |¡}t |ts:tjdt| tdd dS || @ S )z`
|
Implementation of & operator when left operand is not a :class:`ParserElement`
|
ry r rz Nr rx r r r Ú__rand__3 s
|
|
|
ÿzParserElement.__rand__c C s t | S )zH
|
Implementation of ~ operator - returns :class:`NotAny`
|
)r7 rß r r r Ú
|
__invert__? s zParserElement.__invert__c C s t d| jj d S )Nz%r object is not iterable)r1 rÙ r rß r r r rM E s zParserElement.__iter__c C s z t |tr|f}t| W n tk
|
r8 ||f}Y nX t|dkrzt d |dd
t|dkrrd t|¡nd¡¡ | t|dd
}|S )a
|
use ``[]`` indexing notation as a short form for expression repetition:
|
- ``expr[n]`` is equivalent to ``expr*n``
|
- ``expr[m, n]`` is equivalent to ``expr*(m, n)``
|
- ``expr[n, ...]`` or ``expr[n,]`` is equivalent
|
to ``expr*n + ZeroOrMore(expr)``
|
(read as "at least n instances of ``expr``")
|
- ``expr[..., n]`` is equivalent to ``expr*(0, n)``
|
(read as "0 to n instances of ``expr``")
|
- ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)``
|
- ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)``
|
``None`` may be used in place of ``...``.
|
|
Note that ``expr[..., n]`` and ``expr[m, n]``do not raise an exception
|
if more than ``n`` ``expr``s exist in the input stream. If this behavior is
|
desired, then write ``expr[..., n] + ~expr``.
|
r z.only 1 or 2 index arguments supported ({0}{1})NrÆ z ... [{0}]r» ) r r rL r1 rÛ r~ r rø r )rÐ ra r§ r r r r J s
|
|
ÿþzParserElement.__getitem__c C s |dk r| |¡S | ¡ S dS )aý
|
Shortcut for :class:`setResultsName`, with ``listAllMatches=False``.
|
|
If ``name`` is given with a trailing ``'*'`` character, then ``listAllMatches`` will be
|
passed as ``True``.
|
|
If ``name` is omitted, same as calling :class:`copy`.
|
|
Example::
|
|
# these are equivalent
|
userdata = Word(alphas).setResultsName("name") + Word(nums + "-").setResultsName("socsecno")
|
userdata = Word(alphas)("name") + Word(nums + "-")("socsecno")
|
N)r rl rj r r r Ú__call__n s
|
zParserElement.__call__c C s t | S )z
|
Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from
|
cluttering up returned output.
|
)rJ rß r r r Úsuppress s zParserElement.suppressc C s
|
d| _ | S )a
|
Disables the skipping of whitespace before matching the characters in the
|
:class:`ParserElement`'s defined pattern. This is normally only used internally by
|
the pyparsing module, but may be needed in some whitespace-sensitive grammars.
|
F©rí rß r r r ÚleaveWhitespace s z ParserElement.leaveWhitespacec C s d| _ || _d| _| S )z8
|
Overrides the default whitespace chars
|
TF)rí rî rï )rÐ rá r r r ÚsetWhitespaceChars s z ParserElement.setWhitespaceCharsc C s
|
d| _ | S )zì
|
Overrides default behavior to expand ``<TAB>``s to spaces before parsing the input string.
|
Must be called before ``parseString`` when the input grammar contains elements that
|
match ``<TAB>`` characters.
|
T)rñ rß r r r Ú 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/ rJ rò r÷ rl rx r r r Úignore¤ s
|
|
|
zParserElement.ignorec C s" |pt |p t|ptf| _d| _| S )zT
|
Enable display of debugging messages while doing pattern matching.
|
T)r¿ rà rÄ rø ró )rÐ Ú startActionÚ successActionÚexceptionActionr r r ÚsetDebugActions¼ s þz ParserElement.setDebugActionsc C s |r| ttt¡ nd| _| S )a
|
Enable display of debugging messages while doing pattern matching.
|
Set ``flag`` to True to enable, False to disable.
|
|
Example::
|
|
wd = Word(alphas).setName("alphaword")
|
integer = Word(nums).setName("numword")
|
term = wd | integer
|
|
# turn on debugging for wd
|
wd.setDebug()
|
|
OneOrMore(term).parseString("abc 123 xyz 890")
|
|
prints::
|
|
Match alphaword at loc 0(1,1)
|
Matched alphaword -> ['abc']
|
Match alphaword at loc 3(1,4)
|
Exception raised:Expected alphaword (at char 4), (line:1, col:5)
|
Match alphaword at loc 7(1,8)
|
Matched alphaword -> ['xyz']
|
Match alphaword at loc 11(1,12)
|
Exception raised:Expected alphaword (at char 12), (line:1, col:13)
|
Match alphaword at loc 15(1,16)
|
Exception raised:Expected alphaword (at char 15), (line:1, col:16)
|
|
The output shown is that produced by the default debug actions - custom debug actions can be
|
specified using :class:`setDebugActions`. Prior to attempting
|
to match the ``wd`` expression, the debugging message ``"Match <exprname> at loc <n>(<line>,<col>)"``
|
is shown. Then if the parse succeeds, a ``"Matched"`` message is shown, or an ``"Exception raised"``
|
message is shown. Also note the use of :class:`setName` to assign a human-readable name to the expression,
|
which makes debugging and exception messages easier to understand - for instance, the default
|
name created for the :class:`Word` expression without calling ``setName`` is ``"W:(ABCD...)"``.
|
F)r£ r¿ rà rÄ ró )rÐ Úflagr r r rÿ Æ s %zParserElement.setDebugc C s | j S r© r³ rß r r r rÝ ñ s zParserElement.__str__c C s t | S r© rÞ rß r r r rà ô s zParserElement.__repr__c C s d| _ d | _| S r )rô rê rß r r r ra ÷ s zParserElement.streamlinec C s d S r© r r r r r ÚcheckRecursionü s z ParserElement.checkRecursionc C s | g ¡ dS )zj
|
Check defined expressions for valid structure, check for infinite recursive definitions.
|
N)r¥ )rÐ Ú validateTracer r r Úvalidateÿ s zParserElement.validatec C s¢ z | ¡ }W n2 tk
|
r> t|d}| ¡ }W 5 Q R X Y nX z| ||¡W S tk
|
r } z0tjrj n"t|dddk r| |j ¡|_ |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.
|
Úrrú N)
|
Úreadr× Úopenrf r< rC rc rÛ rç rú )rÐ Úfile_or_filenamerd Ú file_contentsÚfr r r r Ú parseFile
|
s zParserElement.parseFilec C s> | |kr dS t |tr | |¡S t |tr:t| t|kS dS r )r r/ rl rC Úvarsrx r r r Ú__eq__
|
s
|
|
|
zParserElement.__eq__c C s
|
| |k S r© r rx r r r Ú__ne__$
|
s zParserElement.__ne__c C s t | S r© )Úidrß r r r Ú__hash__'
|
s zParserElement.__hash__c C s | |kS r© r rx r r r Ú__req__*
|
s zParserElement.__req__c C s
|
| |k S r© r rx r r r Ú__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= ``True``) - flag to pass to :class:`parseString` when running tests
|
|
Example::
|
|
expr = Word(nums)
|
assert expr.matches("100")
|
©rd TFN)rf r¨ r< )rÐ Ú
|
testStringrd r r r rl 0
|
s
|
zParserElement.matchesú#c C sê t |tr"tttj| ¡ ¡ }t |tr4t|}|dkrBt j
|
}|j } g }
|
g } d} td t d¡ t¡} d}|D ]j}|dk r| |d¡s| r¢|s¢| |¡ qt|s¨qt| rºdd | ¡ nd|g}g } z"| | |¡¡}| j||d}W nô tk
|
r } zt |tr d nd}d|krP| t|j|¡ | d
|
t|j|d d | ¡ n| d
|
|j d | ¡ | d t| ¡ | o|} |}W 5 d}~X Y n tk
|
rÜ } z$| dt| ¡ | oÆ|} |}W 5 d}~X Y nÒX | oè| } |dk rzR|||}|dk r6t |t r&| | ¡ ¡ n| t|¡ n| | ¡ ¡ W nR tk
|
r } z2| |j |d¡ | d |j t |j |¡¡ W 5 d}~X Y nX n| |j |d¡ |rÒ|rÄ| d¡ | d |¡ |
|
||f¡ qt| |
|
fS )as
|
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= ``True``) - flag to pass to :class:`parseString` when running tests
|
- comment - (default= ``'#'``) - expression for indicating embedded comments in the test
|
string; pass None to disable comment filtering
|
- fullDump - (default= ``True``) - dump results as list followed by results names in nested outline;
|
if False, only dump nested list
|
- printResults - (default= ``True``) prints test output to stdout
|
- failureTests - (default= ``False``) indicates if these tests are expected to fail parsing
|
- postParse - (default= ``None``) optional callback for successful parse results; called as
|
`fn(test_string, parse_results)` and returns a string to be added to the test output
|
- file - (default=``None``) optional file-like object to which test output will be written;
|
if None, will default to ``sys.stdout``
|
|
Returns: a (success, results) tuple, where success indicates that all tests succeeded
|
(or failed if ``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'.)
|
NTú\nrô u Fr» r¶ z(FATAL)rî r¬ rï zFAIL: zFAIL-EXCEPTION: )r z{0} failed: {1}: {2})!r r/ r* r r rã ÚrstripÚ
|
splitlinesr3 r¢ ÚstdoutÚwriter r| r ry rl r÷ râ r¥ Úlstriprf r< r@ rg rÌ rY r° rA r¥ rø r ré )rÐ Útestsrd ÚcommentÚfullDumpÚ printResultsÚ failureTestsr( ÚfileÚprint_Ú
|
allResultsÚcommentsÚsuccessr§ ÚBOMr r ÚresultrÔ rÊ r Úpp_valuer r r r ÚrunTestsD
|
sn `
|
|
|
|
|
$
|
|
|
|
|
0
|
zParserElement.runTests)F)F)F)T)T)TT)TT)r] )F)N)T)N)F)T)Tr¸ TTFNN)Sr r r rë rß rc r râ rå rì rç rÒ rl r r r r r¤ r r r r r$ rñ r( rò r6 r7 r rE rM rP rV r rU rW r[ r r\ r^ r` rf Ú_MAX_INTro r¥ rt r° rn ry r r
r r r r r r r r r rM r r r r r r r r£ rÿ rÝ rà ra r¥ r§ r® r° r± r³ r´ rµ rl rÌ r r r r rC G s®
|
|
|
|
|
|
|
1
|
|
|
W
|
|
|
"
|
:J0 & J $
|
|
|
+
|
|
|
þc s6 e Zd Zd
|
fdd Zdd Zdd Zdd Z ZS ) r} Fc s> t t| ¡ t|t dd¡| _| j| _|| _|| _ d S )Nr+ ú...)
|
Úsuperr} rÒ r r+ r² rê r! Úanchorr )rÐ r¾ r ©rÙ r r rÒ ê
|
s
|
z_PendingSkip.__init__c s\ t | d¡d} jrNdd } fdd} j| |¡ | |¡B | S j| | S )NrÎ r c S s, | j r| j ¡ dgkr(| d= | dd ¡ d S )Nr» r Ú_skipped)rÒ r" r` r r r r r ô
|
s z'_PendingSkip.__add__.<locals>.must_skipc s< | j ¡ dd
dgkr8| d¡}dt j d | d< d S )Nr r» rÒ z missing <r )rÒ r" r` r rÐ )r Úskippedrß r r Ú show_skipø
|
s
|
z'_PendingSkip.__add__.<locals>.show_skip)rG r r rÐ r )rÐ rm Úskipperr rÔ r rß r rn ñ
|
s
|
ÿÿz_PendingSkip.__add__c C s | j S r© )rê rß r r r rà s z_PendingSkip.__repr__c G s t dd S )NzBuse of `...` expression without following SkipTo target expression)r° ©rÐ rÏ r r r rñ s z_PendingSkip.parseImpl)F)r r r rÒ rn rà rñ Ú __classcell__r r rÑ r r} ç
|
s r} c s e Zd ZdZ fddZ ZS )rK zYAbstract :class:`ParserElement` subclass, for defining atomic
|
matching patterns.
|
c s t t| jdd d S ©NF©rû )rÏ rK rÒ rß rÑ r r rÒ s zToken.__init__©r r r rë rÒ r× r r rÑ r rK 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)rÏ r+ rÒ r! rð rõ rß rÑ r r rÒ s zEmpty.__init__rÚ r r rÑ r r+ s c s* e Zd ZdZ fddZdddZ ZS )r6 z#A token that will never match.
|
c s* t t| ¡ d| _d| _d| _d| _d S )Nr6 TFzUnmatchable token)rÏ r6 rÒ r! rð rõ rö rß rÑ r r rÒ s
|
zNoMatch.__init__Tc C s t ||| j| d S r© )r> rö r% r r r rñ $ s zNoMatch.parseImpl)T©r r r rë rÒ rñ r× r r rÑ r r6 s c s* e Zd ZdZ fddZdddZ ZS )r3 aÒ Token to exactly match a specified string.
|
|
Example::
|
|
Literal('blah').parseString('blah') # -> ['blah']
|
Literal('blah').parseString('blahfooblah') # -> ['blah']
|
Literal('blah').parseString('bla') # -> Exception: Expected "blah"
|
|
For case-insensitive matching, use :class:`CaselessLiteral`.
|
|
For keyword matching (force word break before and after the matched string),
|
use :class:`Keyword` or :class:`CaselessKeyword`.
|
c s t t| ¡ || _t|| _z|d | _W n* tk
|
rV tj dt
|
dd t | _ Y nX dt | j | _d| j | _d| _d| _| jdkrt| tkrt| _ d S ) Nr z2null string passed to Literal; use Empty() insteadr rz ú"%s"rý Fr¬ )rÏ r3 rÒ ÚmatchrÛ ÚmatchLenÚfirstMatchCharr2 r~ r r r+ rÙ r¨ r! rö rð rõ ré Ú_SingleCharLiteral©rÐ Ú matchStringrÑ r r rÒ 6 s"
|
ÿ zLiteral.__init__Tc C s@ || | j kr,| | j|¡r,|| j | jfS t||| j| d S r© )rß r rÝ rÞ r> rö r% r r r rñ J s zLiteral.parseImpl)TrÛ r r rÑ r r3 ( s c @ s e Zd ZdddZdS )rà Tc C s0 || | j kr |d | jfS t||| j| d S r! )rß rÝ r> rö r% r r r rñ P s z _SingleCharLiteral.parseImplN)T©r r r rñ r r r r rà O s rà c sL e Zd ZdZed Zd fdd Zddd Z fd
|
d Ze d d Z
|
Z S )r0 a Token to exactly match a specified string as a keyword, that is,
|
it must be immediately followed by a non-keyword character. Compare
|
with :class:`Literal`:
|
|
- ``Literal("if")`` will match the leading ``'if'`` in
|
``'ifAndOnlyIf'``.
|
- ``Keyword("if")`` will not; it will only match the leading
|
``'if'`` in ``'if x=1'``, or ``'if(y==2)'``
|
|
Accepts two optional constructor arguments in addition to the
|
keyword string:
|
|
- ``identChars`` is a string of characters that would be valid
|
identifier characters, defaulting to all alphanumerics + "_" and
|
"$"
|
- ``caseless`` allows case-insensitive matching, default is ``False``.
|
|
Example::
|
|
Keyword("start").parseString("start") # -> ['start']
|
Keyword("start").parseString("starting") # -> Exception
|
|
For case-insensitive matching, use :class:`CaselessKeyword`.
|
ú_$NFc 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() insteadr rz rÜ rý F)rÏ r0 rÒ ÚDEFAULT_KEYWORD_CHARSrÝ rÛ rÞ rß r2 r~ r r r! rö rð rõ ÚcaselessÚupperÚ caselessmatchrû Ú
|
identChars)rÐ râ ré ræ rÑ r r rÒ s 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% r r r rñ s. ÿþýüÿþýýzKeyword.parseImplc s t t| ¡ }tj|_|S r© )rÏ r0 rl rå ré )rÐ r¿ rÑ r r rl s z Keyword.copyc C s
|
| t _dS )z,Overrides the default Keyword chars
|
N)r0 rå rà r r r ÚsetDefaultKeywordChars s z Keyword.setDefaultKeywordChars)NF)T) r r r rë rS rå rÒ rñ rl r rê r× r r rÑ r r0 X s
|
c s* e Zd ZdZ fddZdddZ ZS )r& af Token to match a specified string, ignoring case of letters.
|
Note: the matched results will always be in the case of the given
|
match string, NOT the case of the input text.
|
|
Example::
|
|
OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
|
|
(Contrast with example for :class:`CaselessKeyword`.)
|
c s6 t t| | ¡ ¡ || _d| j | _d| j | _d S )Nz'%s'rý )rÏ r& rÒ rç Ú returnStringr! rö rá rÑ r r rÒ ± s zCaselessLiteral.__init__Tc C s@ |||| j
¡ | jkr,|| j | jfS t||| j| d S r© )rÞ rç rÝ rë r> rö r% r r r rñ ¸ s zCaselessLiteral.parseImpl)TrÛ r r rÑ r r& ¦ s
|
c s" e Zd ZdZd fdd Z ZS )r% zÕ
|
Caseless version of :class:`Keyword`.
|
|
Example::
|
|
OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
|
|
(Contrast with example for :class:`CaselessLiteral`.)
|
Nc s t t| j||dd d S )NT©ræ )rÏ r% rÒ )rÐ râ ré rÑ r r rÒ Ç s zCaselessKeyword.__init__)NrÚ r r rÑ r r% ½ s c s, e Zd ZdZd fdd Zd ddZ ZS )
|
r a A variation on :class:`Literal` which matches "close" matches,
|
that is, strings with at most 'n' mismatching characters.
|
:class:`CloseMatch` takes parameters:
|
|
- ``match_string`` - string to be matched
|
- ``maxMismatches`` - (``default=1``) maximum number of
|
mismatches allowed to count as a match
|
|
The results from a successful parse will contain the matched text
|
from the input string and the following named results:
|
|
- ``mismatches`` - a list of the positions within the
|
match_string where mismatches were found
|
- ``original`` - the original match_string used to compare
|
against the input string
|
|
If ``mismatches`` is an empty list, then the match was an exact
|
match.
|
|
Example::
|
|
patt = CloseMatch("ATCATCGAATGGA")
|
patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
|
patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
|
|
# exact match
|
patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
|
|
# close match allowing up to 2 mismatches
|
patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
|
patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
|
r¬ c sB t t| ¡ || _|| _|| _d| j| jf | _d| _d| _d S )Nz&Expected %r (with up to %d mismatches)F) rÏ r rÒ r! Ú match_stringÚ maxMismatchesrö rõ rð )rÐ rí rî rÑ r r rÒ ë s zCloseMatch.__init__Tc C sÆ |}t |}|t | j }||kr²| j}d}g } | j}
|
tt|||
|D ]2\}} | \} } | | krL| |¡ t | |
|
krL q²qL|d }t|||
g}||d< | |d< ||fS t||| j| d S )Nr r¬ ÚoriginalÚ
|
mismatches) rÛ rí rî rü r± r÷ rA r> rö )rÐ r½ rÌ r
|
Ústartr# Úmaxlocrí Úmatch_stringlocrð rî Ús_mÚsrcÚmatÚresultsr r r rñ ô s(
|
zCloseMatch.parseImpl)r¬ )TrÛ r r rÑ r r Ê s c s8 e Zd ZdZd fdd Zdd d
|
Z fd d Z ZS )rN aX Token for matching words composed of allowed character sets.
|
Defined with string containing all allowed initial characters, an
|
optional string containing allowed body characters (if omitted,
|
defaults to the initial character set), and an optional minimum,
|
maximum, and/or exact length. The default value for ``min`` is
|
1 (a minimum value < 1 is not valid); the default values for
|
``max`` and ``exact`` are 0, meaning no maximum or exact
|
length restriction. An optional ``excludeChars`` parameter can
|
list characters that might be found in the input ``bodyChars``
|
string; useful to define a word of all printables except for one or
|
two characters, for instance.
|
|
:class:`srange` is useful for defining custom character set strings
|
for defining ``Word`` expressions, using range notation from
|
regular expression character sets.
|
|
A common mistake is to use :class:`Word` to match a specific literal
|
string, as in ``Word("Address")``. Remember that :class:`Word`
|
uses the string argument to define *sets* of matchable characters.
|
This expression would match "Add", "AAA", "dAred", or any other word
|
made up of the characters 'A', 'd', 'r', 'e', and 's'. To match an
|
exact literal string, use :class:`Literal` or :class:`Keyword`.
|
|
pyparsing includes helper strings for building Words:
|
|
- :class:`alphas`
|
- :class:`nums`
|
- :class:`alphanums`
|
- :class:`hexnums`
|
- :class:`alphas8bit` (alphabetic characters in ASCII range 128-255
|
- accented, tilded, umlauted, etc.)
|
- :class:`punc8bit` (non-alphabetic characters in ASCII range
|
128-255 - currency, symbols, superscripts, diacriticals, etc.)
|
- :class:`printables` (any non-whitespace character)
|
|
Example::
|
|
# a word composed of digits
|
integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
|
|
# a word with a leading capital, and zero or more lowercase
|
capital_word = Word(alphas.upper(), alphas.lower())
|
|
# hostnames are alphanumeric, with leading alpha, and '-'
|
hostname = Word(alphas, alphanums + '-')
|
|
# roman numeral (not a strict parser, accepts invalid mix of characters)
|
roman = Word("IVXLCDM")
|
|
# any string of non-whitespace characters, except for ','
|
csv_value = Word(printables, excludeChars=",")
|
Nr¬ r Fc sä t t| ¡ rNt d fdd|D ¡}|rNd fdd|D ¡}|| _t|| _|rt|| _t|| _n|| _t|| _|dk| _ |dk rt
|
d|| _ |dkr´|| _ nt | _ |dkrÎ|| _ || _ t| | _d| j | _d | _|| _d
|
| j| j krà|dkrà|dkrà|dkrà| j| jkr@d t| j | _nHt| jdkrnd t | j¡t| jf | _nd t| jt| jf | _| jr d| j d | _zt | j¡| _W n tk
|
rÎ d | _Y nX | jj| _t | _ d S )Nr» c 3 s | ]}| kr|V qd S r© r r¾ ©Ú excludeCharsr r r« H s z Word.__init__.<locals>.<genexpr>c 3 s | ]}| kr|V qd S r© r r¾ rø r r r« J s r r¬ zZcannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permittedrý Frî z[%s]+z%s[%s]*z [%s][%s]*z\b) rÏ rN rÒ rû râ Ú initCharsOrigÚ initCharsÚ bodyCharsOrigÚ bodyCharsÚ maxSpecifiedr ÚminLenÚmaxLenrÍ r¨ r! rö rõ Ú asKeywordÚ_escapeRegexRangeCharsÚreStringrÛ r ÚescapeÚcompiler° rÝ Úre_matchÚ
|
_WordRegexrÙ )rÐ rû rý ÚminÚmaxÚexactr rù rÑ rø r rÒ D sZ
|
|
|
|
0 ÿ
|
|
ÿ
|
z Word.__init__Tc C sü || | j kr t||| j| |}|d7 }t|}| j}|| j }t||}||k rj|| |krj|d7 }qLd}|| | jk rd}nV| jr¢||k r¢|| |kr¢d}n6| j rØ|dkrÀ||d |ksÔ||k rØ|| |krØd}|rìt||| j| ||||
fS )Nr¬ FTr )
|
rû r> rö rÛ rý r r rÿ rþ r ) rÐ r½ rÌ r
|
rñ r# Ú bodycharsrò ÚthrowExceptionr r r rñ } s2
|
|
|
ÿ
|
ÿzWord.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@ ©r¯ r r r Ú
|
charsAsStr¡ s z Word.__str__.<locals>.charsAsStrz
|
W:(%s, %s)zW:(%s))rÏ rN rÝ r° rê rú rü )rÐ r rÑ r r rÝ s
|
z Word.__str__)Nr¬ r r FN)T©r r r rë rÒ rñ rÝ r× r r rÑ r rN s 49
|
c @ s e Zd ZdddZdS )r Tc C s4 | ||¡}|s t||| j| | ¡ }|| ¡ fS r© )r r> rö ÚendÚgroup)rÐ r½ rÌ r
|
rÊ r r r rñ ¯ s
|
z_WordRegex.parseImplN)Trã r r r r r ® s r c s" e Zd ZdZd fdd Z ZS )rR zA short-cut class for defining ``Word(characters, exact=1)``,
|
when defining a match of any single character in a string of
|
characters.
|
FNc sZ t t| j|d||d dtd | j¡ | _|r>d| j | _t | j¡| _| jj | _
|
d S )Nr¬ )r
|
r rù ú[%s]r» z\b%s\b) rÏ rR rÒ r râ rû r r r rÝ r )rÐ Úcharsetr rù rÑ r r rÒ ½ s z Char.__init__)FNrÚ r r rÑ r rR ¸ s c sT e Zd ZdZd fdd ZdddZdd d
|
Zdd d Z fd dZdd Z Z
|
S )rF ah Token for matching strings that match a given regular
|
expression. Defined with string specifying the regular expression in
|
a form recognized by the stdlib Python `re module <https://docs.python.org/3/library/re.html>`_.
|
If the given regex contains named groups (defined using ``(?P<name>...)``),
|
these will be preserved as named parse results.
|
|
If instead of the Python stdlib re module you wish to use a different RE module
|
(such as the `regex` module), you can replace it by either building your
|
Regex object with a compiled RE that was compiled using regex:
|
|
Example::
|
|
realnum = Regex(r"[+-]?\d+\.\d*")
|
date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
|
# ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
|
roman = Regex(r"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
|
|
# use regex module instead of stdlib re module to construct a Regex using
|
# a compiled regular expression
|
import regex
|
parser = pp.Regex(regex.compile(r'[0-9]'))
|
|
r Fc s$ t t| ¡ t|tr|s,tjdtdd || _|| _ z t
|
| j| j ¡| _
|
| j| _ W q¾ t jk
|
r tjd| tdd Y q¾X n8t|dr¶t|dr¶|| _
|
|j | _| _ || _ ntd| j
|
j| _t| | _d| j | _d | _| d
|
¡d k | _|| _|| _| jr| j| _| jr | j | _d S ) a The parameters ``pattern`` and ``flags`` are passed
|
to the ``re.compile()`` function as-is. See the Python
|
`re module <https://docs.python.org/3/library/re.html>`_ module for an
|
explanation of the acceptable patterns and flags.
|
z0null string passed to Regex; use Empty() insteadr rz ú$invalid pattern (%s) passed to RegexÚpatternrÝ zCRegex may only be constructed with a string or a compiled RE objectrý Fr» N) rÏ rF rÒ r r/ r~ r r r Úflagsr r r Ú sre_constantsÚerrorrQ r1 rÝ r r¨ r! rö rõ rð Ú asGroupListÚasMatchÚparseImplAsGroupListrñ ÚparseImplAsMatch)rÐ r r r r rÑ r r rÒ Þ sD
|
ÿ
|
ÿ
|
|
|
zRegex.__init__Tc C sb | ||¡}|s t||| j| | ¡ }t| ¡ }| ¡ }|rZ| ¡ D ]\}}|||< qH||fS r© )r r> rö r rA r Ú groupdictr? ) rÐ r½ rÌ r
|
rÊ r§ Údr8 r5 r r r rñ s
|
zRegex.parseImplc C s8 | ||¡}|s t||| j| | ¡ }| ¡ }||fS r© )r r> rö r Úgroups©rÐ r½ rÌ r
|
rÊ r§ r r r r s zRegex.parseImplAsGroupListc C s4 | ||¡}|s t||| j| | ¡ }|}||fS r© )r r> rö r r! r r r r ! s zRegex.parseImplAsMatchc sF zt t| ¡ W S tk
|
r$ Y nX | jd kr@dt| j | _| jS )NzRe:(%s))rÏ rF rÝ r° rê r r rß rÑ r r rÝ * s
|
z Regex.__str__c sl j r tjdtdd t jr@t r@tjdtdd t jrT fdd}n fdd} |¡S )a
|
Return Regex with an attached parse action to transform the parsed
|
result as if called using `re.sub(expr, repl, string) <https://docs.python.org/3/library/re.html#re.sub>`_.
|
|
Example::
|
|
make_html = Regex(r"(\w+):(.*?):").sub(r"<\1>\2</\1>")
|
print(make_html.transformString("h1:main title:"))
|
# prints "<h1>main title</h1>"
|
z-cannot use sub() with Regex(asGroupList=True)r rz z9cannot use sub() with a callable with Regex(asMatch=True)c s | d ¡S r )Úexpand©r0 )Úreplr r rÇ K s zRegex.sub.<locals>.pac s j | d ¡S r )r r9 r# ©r$ rÐ r r rÇ N s )r r~ r r Ú SyntaxErrorr r r )rÐ r$ rÇ r r% r r9 5 s ÿ ÿz Regex.sub)r FF)T)T)T) r r r rë rÒ rñ r r rÝ r9 r× r r rÑ r rF Æ s -
|
|
|
c s8 e Zd ZdZd fdd Zd ddZ fd d
|
Z ZS ) rD a&
|
Token for matching strings that are delimited by quoting characters.
|
|
Defined with the following parameters:
|
|
- quoteChar - string of one or more characters defining the
|
quote delimiting string
|
- escChar - character to escape quotes, typically backslash
|
(default= ``None``)
|
- escQuote - special quote sequence to escape an embedded quote
|
string (such as SQL's ``""`` to escape an embedded ``"``)
|
(default= ``None``)
|
- multiline - boolean indicating whether quotes can span
|
multiple lines (default= ``False``)
|
- unquoteResults - boolean indicating whether the matched text
|
should be unquoted (default= ``True``)
|
- endQuoteChar - string of one or more characters defining the
|
end of the quote delimited string (default= ``None`` => same as
|
quoteChar)
|
- convertWhitespaceEscapes - convert escaped whitespace
|
(``'\t'``, ``'\n'``, etc.) to actual whitespace
|
(default= ``True``)
|
|
Example::
|
|
qs = QuotedString('"')
|
print(qs.searchString('lsjdf "This is the quote" sldjf'))
|
complex_qs = QuotedString('{{', endQuoteChar='}}')
|
print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
|
sql_qs = QuotedString('"', escQuote='""')
|
print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
|
|
prints::
|
|
[['This is the quote']]
|
[['This is the "quote"']]
|
[['This is the quote with "embedded" quotes']]
|
NFTc
|
sX 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 _ jj _ W n0 t j!k
|
r0 tjd j tdd Y nX t" _#d j# _$d _%d _&d S )Nz$quoteChar cannot be the empty stringr rz 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ß r r r« ¡ s þ ÿz(QuotedString.__init__.<locals>.<genexpr>r ú)z|(?:%s)z|(?:%s.)z(.)z)*%sr rý FT)'rÏ rD rÒ rã r~ r r r& Ú 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) r- r. Ú multiliner/ r' r0 rÑ rß r rÒ y sv
|
|
|
þ
|
þþþÿ ÿ
|
zQuotedString.__init__c C sÒ || | j kr| ||¡p d }|s2t||| j| | ¡ }| ¡ }| jrÊ|| j| j
}t |t
|
rÊd|kr| j rddddd}| ¡ D ]\}}| ||¡}q| jr´t | jd|¡}| jrÊ| | j| j¡}||fS )NrÚ ú rô ú ú )ú\tr¹ z\fz\rz\g<1>)r+ r r> rö r r r/ r* r, r r/ r0 r? r² r- r r9 r3 r. r' ) rÐ r½ rÌ r
|
rÊ r§ Úws_mapÚwslitÚwscharr r r rñ º 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)rÏ rD rÝ r° rê r) r' rß rÑ r r rÝ Ý s
|
zQuotedString.__str__)NNFTNT)Tr r r rÑ r rD R s & ÿA
|
#c s8 e Zd ZdZd fdd Zd ddZ fd d
|
Z ZS ) r' aü Token for matching words composed of characters *not* in a given
|
set (will include whitespace in matched characters if not listed in
|
the provided exclusion set - see example). Defined with string
|
containing all disallowed characters, and an optional minimum,
|
maximum, and/or exact length. The default value for ``min`` is
|
1 (a minimum value < 1 is not valid); the default values for
|
``max`` and ``exact`` are 0, meaning no maximum or exact
|
length restriction.
|
|
Example::
|
|
# define a comma-separated-value as anything that is not a ','
|
csv_value = CharsNotIn(',')
|
print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
|
|
prints::
|
|
['dkls', 'lsdkjf', 's12 34', '@!#', '213']
|
r¬ r c 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ý )rÏ r' rÒ rí ÚnotCharsr rÿ r rÍ r¨ r! rö rð rõ )rÐ r< r r r
|
rÑ r r 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Ð r½ rÌ r
|
rñ ÚnotcharsÚmaxlenr r r 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))rÏ r' rÝ r° rê rÛ r< rß rÑ r r rÝ & s
|
zCharsNotIn.__str__)r¬ r r )Tr r r rÑ r r' é s
|
c s` e Zd ZdZdddddddd d
|
d d d ddddddddddddZd" fd d Zd#d d!Z ZS )$rM a Special matching class for matching whitespace. Normally,
|
whitespace is ignored by pyparsing grammars. This class is included
|
when some whitespace structures are significant. Define with
|
a string containing the whitespace characters to be matched; default
|
is ``" \t\r\n"``. Also takes optional ``min``,
|
``max``, and ``exact`` arguments, as defined for the
|
:class:`Word` class.
|
z<SP>z<TAB>z<LF>z<CR>z<FF>z<NBSP>z<OGHAM_SPACE_MARK>z<MONGOLIAN_VOWEL_SEPARATOR>z <EN_QUAD>z <EM_QUAD>z
|
<EN_SPACE>z
|
<EM_SPACE>z<THREE-PER-EM_SPACE>z<FOUR-PER-EM_SPACE>z<SIX-PER-EM_SPACE>z<FIGURE_SPACE>z<PUNCTUATION_SPACE>z <THIN_SPACE>z <HAIR_SPACE>z<ZERO_WIDTH_SPACE>z<NNBSP>z<MMSP>z<IDEOGRAPHIC_SPACE>)rî r5 rô r7 r6 õ Â u áu á u âu âu âu âu âu â
u âu âu âu âu âu âu â¯u âu ãú
|
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ß r r r« Y s
|
z!White.__init__.<locals>.<genexpr>c s s | ]}t j| V qd S r© )rM Ú whiteStrsr¾ r r r r« [ s Trý r ) rÏ rM rÒ rA r râ rî r! rð rö rÿ r rÍ )rÐ Úwsr r r
|
rÑ rß r rÒ V 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! )rA r> rö r r rÛ rÿ )rÐ r½ rÌ r
|
rñ rò r r r rñ j s
|
|
zWhite.parseImpl)r@ r¬ r r )T)r r r rë rB rÒ rñ r× r r rÑ r rM 4 s6 éc s e Zd Z fddZ ZS )Ú_PositionTokenc s( t t| ¡ | jj| _d| _d| _d S r )rÏ rD rÒ rÙ r r! rð rõ rß rÑ r r rÒ { s
|
z_PositionToken.__init__©r r r rÒ r× r r rÑ r rD z s rD c s2 e Zd ZdZ fddZdd Zd ddZ ZS )
|
r. zaToken to advance to a specific column of input text; useful for
|
tabular report scraping.
|
c s t t| ¡ || _d S r© )rÏ r. rÒ rY )rÐ ÚcolnorÑ r r rÒ
s zGoToColumn.__init__c C s\ t ||| j krXt|}| jr*| ||¡}||k rX|| ¡ rXt ||| j krX|d7 }q*|S r! )rY rÛ rò r Úisspace)rÐ r½ rÌ r# r r r r$ s $
|
zGoToColumn.preParseTc C sD t ||}|| j kr"t||d| || j | }|||
}||fS )NzText not in expected column©rY r> )rÐ r½ rÌ r
|
ÚthiscolÚnewlocr§ r r r rñ s
|
|
zGoToColumn.parseImpl)T)r r r rë rÒ r$ rñ r× r r rÑ r r. s c s* e Zd ZdZ fddZdddZ ZS )r2 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)rÏ r2 rÒ rö rß rÑ r r rÒ ± s zLineStart.__init__Tc C s* t ||dkr|g fS t||| j| d S r! )rY r> rö r% r r r rñ µ s zLineStart.parseImpl)TrÛ r r rÑ r r2 s c s* e Zd ZdZ fddZdddZ ZS )r1 zTMatches if current position is at the end of a line within the
|
parse string
|
c s, t t| ¡ | tj dd¡¡ d| _d S )Nrô r» zExpected end of line)rÏ r1 rÒ r rC rß r² rö rß rÑ r r 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 )Nrô r¬ ©rÛ r> rö r% r r r rñ Ã s zLineEnd.parseImpl)TrÛ r r rÑ r r1 º s c s* e Zd ZdZ fddZdddZ ZS )rI zLMatches if current position is at the beginning of the parse
|
string
|
c s t t| ¡ d| _d S )NzExpected start of text)rÏ rI rÒ rö rß rÑ r r rÒ Ò s zStringStart.__init__Tc C s0 |dkr(|| |d¡kr(t||| j| |g fS r )r$ r> rö r% r r r rñ Ö s zStringStart.parseImpl)TrÛ r r rÑ r rI Î s c s* e Zd ZdZ fddZdddZ ZS )rH zBMatches if current position is at the end of the parse string
|
c s t t| ¡ d| _d S )NzExpected end of text)rÏ rH rÒ rö rß rÑ r r 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! rK r% r r r rñ ä s zStringEnd.parseImpl)TrÛ r r rÑ r rH Ý s c s. e Zd ZdZef fdd ZdddZ ZS )rP ay Matches if the current position is at the beginning of a Word,
|
and is not preceded by any character in a given set of
|
``wordChars`` (default= ``printables``). To emulate the
|
```` behavior of regular expressions, use
|
``WordStart(alphanums)``. ``WordStart`` will also match at
|
the beginning of the string being parsed, or at the beginning of
|
a line.
|
c s" t t| ¡ t|| _d| _d S )NzNot at the start of a word)rÏ rP rÒ rû Ú wordCharsrö ©rÐ rL rÑ r r rÒ ÷ s
|
zWordStart.__init__Tc C s@ |dkr8||d | j ks(|| | j kr8t||| j| |g fS r; )rL r> rö r% r r r rñ ü s ÿzWordStart.parseImpl)T©r r r rë rv rÒ rñ r× r r rÑ r rP î s c s. e Zd ZdZef fdd ZdddZ ZS )rO a_ Matches if the current position is at the end of a Word, and is
|
not followed by any character in a given set of ``wordChars``
|
(default= ``printables``). To emulate the ```` behavior of
|
regular expressions, use ``WordEnd(alphanums)``. ``WordEnd``
|
will also match at the end of the string being parsed, or at the end
|
of a line.
|
c s( t t| ¡ t|| _d| _d| _d S )NFzNot at the end of a word)rÏ rO rÒ rû rL rí rö rM rÑ r r rÒ s
|
zWordEnd.__init__Tc C sP t |}|dkrH||k rH|| | jks8||d | jkrHt||| j| |g fS r; )rÛ rL r> rö )rÐ r½ rÌ r
|
r# r r r rñ s ÿzWordEnd.parseImpl)TrN r r rÑ r rO s c sz e Zd ZdZd fdd Zdd Zdd Z fd d
|
Z fd d Z fd dZ dddZ
|
fddZ d fdd Z Z S )r? z]Abstract subclass of ParserElement, for combining and
|
post-processing parsed tokens.
|
Fc sÈ t t |¡ t|tr"t|}t|tr< |¡g _nt|t rP|g _nnt|t
|
rt|}t dd |D r fdd|D }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 r¾ r r r r« * s z+ParseExpression.__init__.<locals>.<genexpr>c 3 s& | ] }t |tr |¡n|V qd S r© )r r/ rã ©r r rß r r r« + s F)rÏ r? rÒ r r, r* r/ rã ÚexprsrC r
|
r¦ r1 rù ©rÐ rP rû rÑ rß r rÒ s"
|
|
|
|
|
zParseExpression.__init__c C s | j |¡ d | _| S r© )rP r÷ rê rx r r r r÷ 4 s zParseExpression.appendc C s0 d| _ dd | jD | _| jD ] }| ¡ q | S )zExtends ``leaveWhitespace`` defined in base class, and also invokes ``leaveWhitespace`` on
|
all contained expressions.Fc S s g | ] }| ¡ qS r rk rO r r r r = s z3ParseExpression.leaveWhitespace.<locals>.<listcomp>)rí rP r )rÐ r r r r r 9 s
|
|
|
z ParseExpression.leaveWhitespacec sr t |trB|| jkrntt| |¡ | jD ]}| | jd ¡ q*n,tt| |¡ | jD ]}| | jd ¡ qX| S rN )r rJ rò rÏ r? r rP )rÐ rm r rÑ r r r B s
|
|
|
|
zParseExpression.ignorec sN zt t| ¡ W S tk
|
r$ Y nX | jd krHd| jjt| jf | _| jS ©Nz%s:(%s)) rÏ r? rÝ r° rê rÙ r r¨ rP rß rÑ r r rÝ N 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 )Nr r r¬ r rý )rÏ r? ra rP rÛ r rÙ rè rë ró rê rð rõ r¨ rö )rÐ r rm rÑ r r ra X s<
|
|
|
ÿþý
|
ÿþý zParseExpression.streamlineNc C sB |d k r |ng d d
| g }| j D ]}| |¡ q$| g ¡ d S r© )rP r§ r¥ )rÐ r¦ Útmpr r r r r§ z s
|
zParseExpression.validatec s$ t t| ¡ }dd | jD |_|S )Nc S s g | ] }| ¡ qS r rk rO r r r r s z(ParseExpression.copy.<locals>.<listcomp>)rÏ r? rl rP r rÑ r r rl s zParseExpression.copyc sV t jrD| jD ]6}t|tr |jr tjd d|t | j
|
|j¡dd q t t | ||¡S )Nú]{0}: setting results name {1!r} on {2} expression collides with {3!r} on contained expressionr r rz )r r rP r rC rë r~ r rø ré r rÏ r? r ©rÐ r! r r rÑ r r r
s
|
üûz ParseExpression._setResultsName)F)N)F)r r r rë rÒ r÷ r r rÝ ra r§ rl r r× r r rÑ r r? s
|
"
|
c s` e Zd ZdZG dd deZd fdd Z fddZdd d
|
Zd d Z d d Z
|
dd Z Z S )r$ a
|
Requires all given :class:`ParseExpression` s to be found in the given order.
|
Expressions may be separated by whitespace.
|
May be constructed using the ``'+'`` operator.
|
May also be constructed using the ``'-'`` operator, which will
|
suppress backtracking.
|
|
Example::
|
|
integer = Word(nums)
|
name_expr = OneOrMore(Word(alphas))
|
|
expr = And([integer("id"), name_expr("name"), integer("age")])
|
# more easily written as:
|
expr = integer("id") + name_expr("name") + integer("age")
|
c s e Zd Z fddZ ZS )zAnd._ErrorStopc s& t tj| j|| d| _| ¡ d S )Nú-)rÏ r$ r rÒ r! r r© rÑ r r rÒ ¦ s zAnd._ErrorStop.__init__rE r r rÑ r r ¥ s r Tc sà t |}|rt|krg }t|D ]`\}}|tkrv|t|d k rlt ||d jd }| t|d¡ qtdq | |¡ q ||d d
< t t
|
| ||¡ t dd | jD | _ | | jd j¡ | jd j| _d| _d S ) Nr¬ r r z0cannot construct And with sequence ending in ...c s s | ] }|j V qd S r© ©rð rO r r r r« º s z And.__init__.<locals>.<genexpr>r T)r* r| rü rÛ r+ rP r÷ rG r° rÏ r$ rÒ r rð r rî rí rù )rÐ rP rû rS r r¾ Ú
|
skipto_argrÑ r r rÒ « s
|
z And.__init__c sÎ | j r¦tdd | j d d
D r¦t| j d d
D ]^\}}|d krFq4t|tr4|j r4t|j d tr4|j d | j |d |j d< d | j |d < q4dd | j D | _ tt| ¡ t dd | j D | _
|
| S )Nc s s. | ]&}t |to$|jo$t |jd tV qdS ©r N)r r? rP r} rO r r r r« Â s ÿz!And.streamline.<locals>.<genexpr>r r¬ c S s g | ]}|d k r|qS r© r rO r r r r Ë s z"And.streamline.<locals>.<listcomp>c s s | ] }|j V qd S r© rW rO r r r r« Î s ) rP r¦ rü r r? r} rÏ r$ ra r rð )rÐ r r rÑ r r ra ¿ s$ ÿ
|
ÿÿ zAnd.streamlinec 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 Frg r¬ T) rP r r r$ r rB r< rú rÕ r2 rÛ rö r[ ) rÐ r½ rÌ r
|
Ú
|
resultlistÚ errorStopr Ú
|
exprtokensrÔ r r r rñ Ñ s(
|
z And.parseImplc C s t |tr| |¡}| |¡S r© ©r r/ rã r÷ rx r r r rf ê s
|
|
z And.__iadd__c C s6 |d d
| g }| j D ]}| |¡ |js q2qd S r© )rP r¥ rð ©rÐ r ÚsubRecCheckListr r r r r¥ ï s
|
|
|
zAnd.checkRecursionc C s@ t | dr| jS | jd kr:dd dd | jD ¡ d | _| jS )Nr! Ú{rî c s s | ]}t |V qd S r© rÞ rO r r r r« û s z And.__str__.<locals>.<genexpr>Ú}©rQ r! rê râ rP rß r r r rÝ ö s
|
|
|
z And.__str__)T)T) r r r rë r+ r rÒ ra rñ rf r¥ rÝ r× r r rÑ r r$ s
|
c s^ e Zd ZdZd fdd Z fddZddd Zd
|
d Zd d Zdd Z d fdd Z
|
Z S )r; a¿ Requires that at least one :class:`ParseExpression` is found. If
|
two expressions match, the expression that matches the longest
|
string will be used. May be constructed using the ``'^'``
|
operator.
|
|
Example::
|
|
# construct Or using '^' operator
|
|
number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
|
print(number.searchString("123 3.1416 789"))
|
|
prints::
|
|
[['123'], ['3.1416'], ['789']]
|
Fc s: t t| ||¡ | jr0tdd | jD | _nd| _d S )Nc s s | ] }|j V qd S r© rW rO r r r r« s z Or.__init__.<locals>.<genexpr>T)rÏ r; rÒ rP r¦ rð rQ rÑ r r rÒ s z Or.__init__c s. t t| ¡ tjr*tdd | jD | _| S )Nc s s | ] }|j V qd S r© ©rì rO r r r r« s z Or.streamline.<locals>.<genexpr>)rÏ r; ra r# Úcollect_all_And_tokensr¦ rP rì rß rÑ r r ra s z Or.streamlineTc C sÆ 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 t
|
ddd |sä|d d }
|
|
|
|||¡S d} |D ] \} } | | d kr
|
| S z| |||¡\}}W n@ tk
|
r` } z d | _| j|krP| }| j}W 5 d } ~ X Y qìX || krx||f S || d krì||f} qì| dkr| S |d k r´| j|_ |nt||d| d S )Nr r T)ra r> r¬ rY ú no defined alternatives to match) rP r6 r> rú rÌ r2 rÛ rö r÷ Úsortr r rÆ )rÐ r½ rÌ r
|
Ú maxExcLocÚ maxExceptionrl r Úloc2r1 Ú best_exprÚlongestÚloc1Úexpr1r r r r rñ sT
|
|
|
|
|
|
z Or.parseImplc C s t |tr| |¡}| |¡S r© r] rx r r r Ú__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Þ rO r r r r« e s z Or.__str__.<locals>.<genexpr>ra rb rß r r r rÝ ` s
|
|
|
z
|
Or.__str__c C s, |d d
| g }| j D ]}| |¡ qd S r© ©rP r¥ r^ r r r r¥ i s
|
zOr.checkRecursionc sP t js>tjr>tdd | jD r>tjd d|t | j
|
¡dd t t | ||¡S )Nc s s | ]}t |tV qd S r© ©r r$ rO r r r r« q s z%Or._setResultsName.<locals>.<genexpr>ú{0}: setting results name {1!r} on {2} expression may only return a single token for an And alternative, in future will return the full list of tokensr r rz )r# rd r r r¦ rP r~ r rø ré r rÏ r; r r rÑ r r r n s ÿ ýüzOr._setResultsName)F)T)F) r r r rë rÒ ra rñ rn rÝ r¥ r r× r r rÑ r r; s
|
= c s^ e Zd ZdZd fdd Z fddZddd Zd
|
d Zd d Zdd Z d fdd Z
|
Z S )r5 a¸ Requires that at least one :class:`ParseExpression` is found. If
|
two expressions match, the first one listed is the one that will
|
match. May be constructed using the ``'|'`` operator.
|
|
Example::
|
|
# construct MatchFirst using '|' operator
|
|
# watch the order of expressions to match
|
number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
|
print(number.searchString("123 3.1416 789")) # Fail! -> [['123'], ['3'], ['1416'], ['789']]
|
|
# put more selective expression first
|
number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
|
print(number.searchString("123 3.1416 789")) # Better -> [['123'], ['3.1416'], ['789']]
|
Fc s: t t| ||¡ | jr0tdd | jD | _nd| _d S )Nc s s | ] }|j V qd S r© rW rO r r r r« s z&MatchFirst.__init__.<locals>.<genexpr>T)rÏ r5 rÒ rP r¦ rð rQ rÑ r r rÒ s zMatchFirst.__init__c s. t t| ¡ tjr*tdd | jD | _| S )Nc s s | ] }|j V qd S r© rc rO r r r r« s z(MatchFirst.streamline.<locals>.<genexpr>)rÏ r5 ra r# rd r¦ rP rì rß rÑ r r ra s zMatchFirst.streamlineTc 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 )Nr re )rP r r> rÌ r2 rÛ rö rÆ ) rÐ r½ rÌ r
|
rg rh r r§ r1 r r r rñ s$
|
|
|
zMatchFirst.parseImplc C s t |tr| |¡}| |¡S r© r] rx r r r Ú__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Þ rO r r r r« » s z%MatchFirst.__str__.<locals>.<genexpr>ra rb rß r r r rÝ ¶ s
|
|
|
zMatchFirst.__str__c C s, |d d
| g }| j D ]}| |¡ qd S r© ro r^ r r r r¥ ¿ s
|
zMatchFirst.checkRecursionc sP t js>tjr>tdd | jD r>tjd d|t | j
|
¡dd t t | ||¡S )Nc s s | ]}t |tV qd S r© rp rO r r r r« Ç s z-MatchFirst._setResultsName.<locals>.<genexpr>rq r r rz )r# rd r r r¦ rP r~ r rø ré r rÏ r5 r r rÑ r r r Ä s ÿ ýüzMatchFirst._setResultsName)F)T)F) r r r rë rÒ ra rñ rr rÝ r¥ r r× r r rÑ r r5 { s
|
c sH e Zd ZdZd fdd Z fddZdddZd d
|
Zd d Z Z S )r* as Requires all given :class:`ParseExpression` s to be found, but in
|
any order. Expressions may be separated by whitespace.
|
|
May be constructed using the ``'&'`` operator.
|
|
Example::
|
|
color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
|
shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
|
integer = Word(nums)
|
shape_attr = "shape:" + shape_type("shape")
|
posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
|
color_attr = "color:" + color("color")
|
size_attr = "size:" + integer("size")
|
|
# use Each (using operator '&') to accept attributes in any order
|
# (shape and posn are required, color and size are optional)
|
shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
|
|
shape_spec.runTests('''
|
shape: SQUARE color: BLACK posn: 100, 120
|
shape: CIRCLE size: 50 color: BLUE posn: 50,80
|
color:GREEN size:20 shape:TRIANGLE posn:20,40
|
'''
|
)
|
|
prints::
|
|
shape: SQUARE color: BLACK posn: 100, 120
|
['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
|
- color: BLACK
|
- posn: ['100', ',', '120']
|
- x: 100
|
- y: 120
|
- shape: SQUARE
|
|
|
shape: CIRCLE size: 50 color: BLUE posn: 50,80
|
['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
|
- color: BLUE
|
- posn: ['50', ',', '80']
|
- x: 50
|
- y: 80
|
- shape: CIRCLE
|
- size: 50
|
|
|
color: GREEN size: 20 shape: TRIANGLE posn: 20,40
|
['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
|
- color: GREEN
|
- posn: ['20', ',', '40']
|
- x: 20
|
- y: 40
|
- shape: TRIANGLE
|
- size: 20
|
Tc s> t t| ||¡ tdd | jD | _d| _d| _d| _d S )Nc s s | ] }|j V qd S r© rW rO r r r r« s z Each.__init__.<locals>.<genexpr>T) rÏ r* rÒ r rP rð rí ÚinitExprGroupsrì rQ rÑ r r rÒ
|
s
|
z Each.__init__c s( t t| ¡ tdd | jD | _| S )Nc s s | ] }|j V qd S r© rW rO r r r r« s z"Each.streamline.<locals>.<genexpr>)rÏ r* ra r rP rð rß rÑ r r ra s zEach.streamlinec 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: r² r¾ rO r r r r« s
|
z!Each.parseImpl.<locals>.<genexpr>c S s g | ]}t |tr|jqS r ©r r: r¾ rO r r r r s
|
z"Each.parseImpl.<locals>.<listcomp>c S s$ g | ] }|j rt|ttfs|qS r )rð r r: rF rO r r r r s c S s g | ]}t |tr|jqS r )r rQ r¾ rO r r r r s
|
c S s g | ]}t |tr|jqS r )r r8 r¾ rO r r r r s
|
c S s g | ]}t |tttfs|qS r )r r: rQ r8 rO r r r r s FTr{ c s s | ]}t |V qd S r© rÞ rO r r r r« 9 s z*Missing one or more required elements (%s)c s$ g | ] }t |tr|j kr|qS r ru rO ©ÚtmpOptr r r = s
|
|
)rt r- rP Úopt1mapÚ optionalsÚmultioptionalsÚ multirequiredÚrequiredr6 r> r÷ rþ r² ÚremoverÛ râ r ÚsumrA )rÐ r½ rÌ r
|
Úopt1Úopt2ÚtmpLocÚtmpReqdÚ
|
matchOrderÚ keepMatchingÚtmpExprsÚfailedr ÚmissingrZ r÷ Ú finalResultsr rv r rñ 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Þ rO r r r r« L s z Each.__str__.<locals>.<genexpr>ra rb rß r r r rÝ G s
|
|
|
z Each.__str__c C s, |d d
| g }| j D ]}| |¡ qd S r© ro r^ r r r r¥ P s
|
zEach.checkRecursion)T)T)
|
r r r rë rÒ ra rñ rÝ r¥ r× r r rÑ r r* Ñ s 8
|
1 c sj e Zd ZdZd fdd ZdddZdd Z fd
|
d Z fd d Zdd Z dddZ
|
fddZ Z S )r= zfAbstract subclass of :class:`ParserElement`, for combining and
|
post-processing parsed tokens.
|
Fc s t t| |¡ t|tr@t| jtr2| |¡}n| t|¡}|| _ d | _
|
|d k r|j | _ |j | _ | |j¡ |j| _|j| _|j| _| j |j¡ d S r© )rÏ r= rÒ r r/ Ú
|
issubclassrã rK r3 r¾ rê rõ rð r rî rí rì rù rò rg ©rÐ r¾ rû rÑ r r rÒ Z s
|
z ParseElementEnhance.__init__Tc C s2 | j d k r | j j|||ddS td|| j| d S )NFrg r» )r¾ r r> rö r% r r r rñ l s
|
z ParseElementEnhance.parseImplc C s* d| _ | j ¡ | _| jd k r&| j ¡ | S r¯ )rí r¾ rl r rß r r r r r s
|
|
|
z#ParseElementEnhance.leaveWhitespacec sr t |trB|| jkrntt| |¡ | jd k rn| j | jd ¡ n,tt| |¡ | jd k rn| j | jd ¡ | S rN )r rJ rò rÏ r= r r¾ rx rÑ r r r y s
|
|
|
|
zParseElementEnhance.ignorec s& t t| ¡ | jd k r"| j ¡ | S r© )rÏ r= ra r¾ rß rÑ r r ra
s
|
|
z ParseElementEnhance.streamlinec C sB | |krt || g |d d
| g }| jd k r>| j |¡ d S r© )rE r¾ r¥ )rÐ r r_ r r r r¥ s
|
|
z"ParseElementEnhance.checkRecursionNc C sB |d kr g }|d d
| g }| j d k r4| j |¡ | g ¡ d S r© ©r¾ r§ r¥ ©rÐ r¦ rS r r r r§ s
|
z ParseElementEnhance.validatec sX zt t| ¡ W S tk
|
r$ Y nX | jd krR| jd k rRd| jjt| jf | _| jS rR ) rÏ r= rÝ r° rê r¾ rÙ r r¨ rß rÑ r r rÝ s zParseElementEnhance.__str__)F)T)N) r r r rë rÒ rñ r r ra r¥ r§ rÝ r× r r rÑ r r= V s
|
|
c s* e Zd ZdZ fddZdddZ ZS )r, ab Lookahead matching of the given parse expression.
|
``FollowedBy`` does *not* advance the parsing position within
|
the input string, it only verifies that the specified parse
|
expression matches at the current position. ``FollowedBy``
|
always returns a null token list. If any results names are defined
|
in the lookahead expression, those *will* be returned for access by
|
name.
|
|
Example::
|
|
# use FollowedBy to match a label only if it is followed by a ':'
|
data_word = Word(alphas)
|
label = data_word + FollowedBy(':')
|
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
|
|
OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
|
|
prints::
|
|
[['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
|
c s t t| |¡ d| _d S r )rÏ r, rÒ rð ©rÐ r¾ rÑ r r rÒ » s zFollowedBy.__init__Tc C s( | j j|||d\}}|d d
= ||fS )Nr4 )r¾ r )rÐ r½ rÌ r
|
Ú_r§ r r r rñ ¿ s
|
zFollowedBy.parseImpl)TrÛ r r rÑ r r, ¥ s c s, e Zd ZdZd fdd Zd
|
ddZ ZS ) r4 ap Lookbehind matching of the given parse expression.
|
``PrecededBy`` does not advance the parsing position within the
|
input string, it only verifies that the specified parse expression
|
matches prior to the current position. ``PrecededBy`` always
|
returns a null token list, but if a results name is defined on the
|
given expression, it is returned.
|
|
Parameters:
|
|
- expr - expression that must match prior to the current parse
|
location
|
- retreat - (default= ``None``) - (int) maximum number of characters
|
to lookbehind prior to the current parse location
|
|
If the lookbehind expression is a string, Literal, Keyword, or
|
a Word or CharsNotIn with a specified exact or maximum length, then
|
the retreat parameter is not required. Otherwise, retreat must be
|
specified to give a maximum number of characters to look back from
|
the current parse position for a lookbehind match.
|
|
Example::
|
|
# VB-style variable names with type prefixes
|
int_var = PrecededBy("#") + pyparsing_common.identifier
|
str_var = PrecededBy("$") + pyparsing_common.identifier
|
|
Nc sÎ t t| |¡ | ¡ ¡ | _d| _d| _d| _t|t rJt
|
|}d| _nVt|t t frf|j }d| _n:t|ttfr|jtkr|j}d| _nt|tr d}d| _|| _dt | | _d| _| j dd ¡ d S )NTFr znot preceded by c S s | td d ¡S r© )rF r6 rÁ r r r r ù r z%PrecededBy.__init__.<locals>.<lambda>)rÏ r4 rÒ r¾ r rð rõ r
|
r r rÛ r3 r0 rÞ rN r' r rÍ rD Úretreatrö rí rè r÷ )rÐ r¾ r rÑ r r rÒ ä s*
|
|
zPrecededBy.__init__r Tc C sâ | j r<|| jk r t||| j|| j }| j ||¡\}}n| jt }|td|| j |
}t||| j} tdt || jd d D ]L}
|
z | |t
|
||
|
¡\}}W n& t k
|
rÎ } z| } W 5 d } ~ X Y qX qÚq| ||fS r; ) r
|
r r> rö r¾ r rH r r< r rÛ r< ) rÐ r½ rÌ r
|
rñ r r§ Ú test_exprÚinstring_sliceÚ last_exprrp Úpber r r rñ û s
|
|
zPrecededBy.parseImpl)N)r TrÛ r r rÑ r r4 È s c s2 e Zd ZdZ fddZd ddZdd Z ZS )
|
r7 a¹ Lookahead to disallow matching with the given parse expression.
|
``NotAny`` does *not* advance the parsing position within the
|
input string, it only verifies that the specified parse expression
|
does *not* match at the current position. Also, ``NotAny`` does
|
*not* skip over leading whitespace. ``NotAny`` always returns
|
a null token list. May be constructed using the '~' operator.
|
|
Example::
|
|
AND, OR, NOT = map(CaselessKeyword, "AND OR NOT".split())
|
|
# take care not to mistake keywords for identifiers
|
ident = ~(AND | OR | NOT) + Word(alphas)
|
boolean_term = Optional(NOT) + ident
|
|
# very crude boolean expression - to support parenthesis groups and
|
# operation hierarchy, use infixNotation
|
boolean_expr = boolean_term + ZeroOrMore((AND | OR) + boolean_term)
|
|
# integers that are followed by "." are actually floats
|
integer = Word(nums) + ~Char(".")
|
c s0 t t| |¡ d| _d| _dt| j | _d S )NFTzFound unwanted token, )rÏ r7 rÒ rí rð r¨ r¾ rö r rÑ r r rÒ * s zNotAny.__init__Tc C s& | j ||¡r t||| j| |g fS r© )r¾ r7 r> rö r% r r r rñ 1 s zNotAny.parseImplc C s4 t | dr| jS | jd kr.dt| j d | _| jS )Nr! z~{ra ©rQ r! rê r¨ r¾ rß r r r rÝ 6 s
|
|
|
zNotAny.__str__)Tr r r rÑ r r7 s
|
c s> e Zd Zd fdd Zdd Zd ddZd fd
|
d Z ZS )Ú_MultipleMatchNc s< t t| |¡ d| _|}t|tr.| |¡}| |¡ d S r )rÏ r rÒ rì r r/ rã ÚstopOn)rÐ r¾ r ÚenderrÑ r r rÒ @ s
|
|
z_MultipleMatch.__init__c C s, t |tr| |¡}|d k r"| nd | _| S r© )r r/ rã Ú not_ender)rÐ r r r r r H s
|
|
z_MultipleMatch.stopOnTc 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 ©NFrg ) r¾ r r r r6 rò r[ r> r2 ) rÐ r½ rÌ r
|
Úself_expr_parseÚself_skip_ignorablesÚ check_enderÚ try_not_enderr0 ÚhasIgnoreExprsr. Ú tmptokensr r r rñ N s*
|
|
|
|
z_MultipleMatch.parseImplFc sf t jrT| jgt| jdg D ]6}t|tr |jr tjd d|t
|
| j |j¡dd q t t | ||¡S )NrP rT r r rz )r r r¾ rÛ r rC rë r~ r rø ré r rÏ r r rU rÑ r r r k s üûz _MultipleMatch._setResultsName)N)T)F)r r r rÒ r rñ r r× r r rÑ r r ? s
|
r c @ s e Zd ZdZdd ZdS )r8 aj Repetition of one or more of the given expression.
|
|
Parameters:
|
- expr - expression that must match one or more times
|
- stopOn - (default= ``None``) - expression for a terminating sentinel
|
(only required if the sentinel would ordinarily match the repetition
|
expression)
|
|
Example::
|
|
data_word = Word(alphas)
|
label = data_word + FollowedBy(':')
|
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
|
|
text = "shape: SQUARE posn: upper left color: BLACK"
|
OneOrMore(attr_expr).parseString(text).pprint() # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
|
|
# use stopOn attribute for OneOrMore to avoid reading label string as part of the data
|
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
|
OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
|
|
# could also be written as
|
(attr_expr * (1,)).parseString(text).pprint()
|
c C s4 t | dr| jS | jd kr.dt| j d | _| jS )Nr! r` z}...r rß r r r rÝ s
|
|
|
zOneOrMore.__str__N)r r r rë rÝ r r r r r8 y s c s8 e Zd ZdZd
|
fdd Zd fdd Zdd Z ZS ) rQ ak Optional repetition of zero or more of the given expression.
|
|
Parameters:
|
- expr - expression that must match zero or more times
|
- stopOn - (default= ``None``) - expression for a terminating sentinel
|
(only required if the sentinel would ordinarily match the repetition
|
expression)
|
|
Example: similar to :class:`OneOrMore`
|
Nc s t t| j||d d| _d S )N©r T)rÏ rQ rÒ rð )rÐ r¾ r rÑ r r rÒ § s zZeroOrMore.__init__Tc s< zt t| |||¡W S ttfk
|
r6 |g f Y S X d S r© )rÏ rQ rñ r> r2 r% rÑ r r rñ « s zZeroOrMore.parseImplc C s4 t | dr| jS | jd kr.dt| j d | _| jS )Nr! rz ú]...r rß r r r rÝ ± s
|
|
|
zZeroOrMore.__str__)N)Tr r r rÑ r rQ s
|
c @ s e Zd Zdd ZeZdd ZdS )Ú
|
_NullTokenc C s dS r¯ r rß r r r rJ ¼ s z_NullToken.__bool__c C s dS rË r rß r r r rÝ ¿ s z_NullToken.__str__N)r r r rJ rµ rÝ r r r r r¢ » s r¢ c s< e Zd ZdZe Zef fdd Zd ddZdd Z Z S )
|
r: aG Optional matching of the given expression.
|
|
Parameters:
|
- expr - expression that must match zero or more times
|
- default (optional) - value to be returned if the optional expression is not found.
|
|
Example::
|
|
# US postal code can be a 5-digit zip, plus optional 4-digit qualifier
|
zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
|
zip.runTests('''
|
# traditional ZIP code
|
12345
|
|
# ZIP+4 form
|
12101-0001
|
|
# invalid ZIP
|
98765-
|
''')
|
|
prints::
|
|
# traditional ZIP code
|
12345
|
['12345']
|
|
# ZIP+4 form
|
12101-0001
|
['12101-0001']
|
|
# invalid ZIP
|
98765-
|
^
|
FAIL: Expected end of text (at char 5), (line:1, col:6)
|
c s. t t| j|dd | jj| _|| _d| _d S )NFrÙ T)rÏ r: rÒ r¾ rì rb rð )rÐ r¾ r\ rÑ r r rÒ é s
|
zOptional.__init__Tc C s| z | j j|||dd\}}W nV ttfk
|
rr | j| jk rj| j jr`t| jg}| j|| j j< qn| jg}ng }Y nX ||fS r )r¾ r r> r2 rb Ú _Optional__optionalNotMatchedrë rA )rÐ r½ rÌ r
|
r0 r r r rñ ï s
|
|
zOptional.parseImplc C s4 t | dr| jS | jd kr.dt| j d | _| jS )Nr! rz r} r rß r r r rÝ ý s
|
|
|
zOptional.__str__)T)
|
r r r rë r¢ r£ rÒ rñ rÝ r× r r rÑ r r: Â s
|
$
|
c s, e Zd ZdZd fdd Zd
|
ddZ ZS ) rG aø Token for skipping over all undefined text until the matched
|
expression is found.
|
|
Parameters:
|
- expr - target expression marking the end of the data to be skipped
|
- include - (default= ``False``) if True, the target expression is also parsed
|
(the skipped text and target expression are returned as a 2-element list).
|
- ignore - (default= ``None``) used to define grammars (typically quoted strings and
|
comments) that might contain false matches to the target expression
|
- failOn - (default= ``None``) define expressions that are not allowed to be
|
included in the skipped test; if found before the target expression is found,
|
the SkipTo is not a match
|
|
Example::
|
|
report = '''
|
Outstanding Issues Report - 1 Jan 2000
|
|
# | Severity | Description | Days Open
|
-----+----------+-------------------------------------------+-----------
|
101 | Critical | Intermittent system crash | 6
|
94 | Cosmetic | Spelling error on Login ('log|n') | 14
|
79 | Minor | System slow when running too many reports | 47
|
'''
|
integer = Word(nums)
|
SEP = Suppress('|')
|
# use SkipTo to simply match everything up until the next SEP
|
# - ignore quoted strings, so that a '|' character inside a quoted string does not match
|
# - parse action will call token.strip() for each matched token, i.e., the description body
|
string_data = SkipTo(SEP, ignore=quotedString)
|
string_data.setParseAction(tokenMap(str.strip))
|
ticket_expr = (integer("issue_num") + SEP
|
+ string_data("sev") + SEP
|
+ string_data("desc") + SEP
|
+ integer("days_open"))
|
|
for tkt in ticket_expr.searchString(report):
|
print tkt.dump()
|
|
prints::
|
|
['101', 'Critical', 'Intermittent system crash', '6']
|
- days_open: 6
|
- desc: Intermittent system crash
|
- issue_num: 101
|
- sev: Critical
|
['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
|
- days_open: 14
|
- desc: Spelling error on Login ('log|n')
|
- issue_num: 94
|
- sev: Cosmetic
|
['79', 'Minor', 'System slow when running too many reports', '47']
|
- days_open: 47
|
- desc: System slow when running too many reports
|
- issue_num: 79
|
- sev: Minor
|
FNc s` t t| |¡ || _d| _d| _|| _d| _t|t rF|
|
|¡| _ n|| _ dt | j | _d S )NTFzNo match found for )rÏ rG rÒ Ú
|
ignoreExprrð rõ Ú includeMatchrì r r/ rã ÚfailOnr¨ r¾ rö )rÐ rm Úincluder r¦ rÑ r r 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¬ rg ) rÛ r¾ r r¦ r7 r¤ r6 r< r> r2 rö rA r¥ )rÐ r½ rÌ r
|
rÀ r# r¾ Ú
|
expr_parseÚself_failOn_canParseNextÚself_ignoreExpr_tryParseÚtmplocÚskiptextÚ
|
skipresultrö r r r rñ M s:
|
zSkipTo.parseImpl)FNN)TrÛ r r rÑ r rG s 9 c sn e Zd ZdZd fdd Zdd Zdd Zd d
|
Zd d Zdd dZ dd Z
|
fddZ d fdd Z Z S )r- a_ Forward declaration of an expression to be defined later -
|
used for recursive grammars, such as algebraic infix notation.
|
When the expression is known, it is assigned to the ``Forward``
|
variable using the '<<' operator.
|
|
Note: take care when assigning to ``Forward`` not to overlook
|
precedence of operators.
|
|
Specifically, '|' has a lower precedence than '<<', so that::
|
|
fwdExpr << a | b | c
|
|
will actually be evaluated as::
|
|
(fwdExpr << a) | b | c
|
|
thereby leaving b and c out as parseable alternatives. It is recommended that you
|
explicitly group the values inserted into the ``Forward``::
|
|
fwdExpr << (a | b | c)
|
|
Converting to use the '<<=' operator instead will avoid this problem.
|
|
See :class:`ParseResults.pprint` for an example of a recursive
|
parser created using ``Forward``.
|
Nc s t t| j|dd d S rØ )rÏ r- rÒ rx rÑ r r rÒ s zForward.__init__c C sj t |tr| |¡}|| _d | _| jj| _| jj| _| | jj¡ | jj | _ | jj
|
| _
|
| j | jj ¡ | S r© ) r r/ rã r¾ rê rõ rð r rî rí rì rò rg rx r r r Ú
|
__lshift__ s
|
|
|
|
|
|
zForward.__lshift__c C s | |> S r© r rx r r r Ú __ilshift__§ s zForward.__ilshift__c C s
|
d| _ | S r¯ r rß r r r r ª s zForward.leaveWhitespacec C s$ | j s d| _ | jd k r | j ¡ | S r )rô r¾ ra rß r r r ra ® s
|
|
|
zForward.streamlinec C sJ |d kr g }| |kr<|d d
| g }| j d k r<| j |¡ | g ¡ d S r© r r r r r r§ µ s
|
zForward.validatec C sl t | dr| jS | jd k r | jS d| _d}z&| jd k rJt| jd d
}nd}W 5 | jjd | | _X | jS )Nr! z: ...rÎ z: iè ÚNone)rQ r! rê rÙ r r¾ r¨ )rÐ Ú retStringr r r rÝ ¿ s
|
|
|
zForward.__str__c s. | j d k rtt| ¡ S t }|| K }|S d S r© )r¾ rÏ r- rl r rÑ r r rl Ó s
|
|
z Forward.copyFc s@ t jr.| jd kr.tjd d|t| j¡dd tt |
|
||¡S )NzR{0}: setting results name {0!r} on {1} expression that has no contained expressionr r rz ) r r r¾ r~ r rø ré r rÏ r- r r rÑ r r r Û s
|
ýüzForward._setResultsName)N)N)F)r r r rë rÒ r® r¯ r ra r§ rÝ rl r r× r r rÑ r r- | s
|
|
c s" e Zd ZdZd fdd Z ZS )rL zW
|
Abstract subclass of :class:`ParseExpression`, for converting parsed results.
|
Fc s t t| |¡ d| _d S r¯ )rÏ rL rÒ rì r rÑ r r rÒ ê s zTokenConverter.__init__)FrÚ r r rÑ r rL æ 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
|
``'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 )rÏ r( rÒ r Úadjacentrí Ú
|
joinStringrù )rÐ r¾ r³ r² rÑ r r rÒ s zCombine.__init__c s( | j rt | |¡ ntt| |¡ | S r© )r² rC r rÏ r( rx rÑ r r r
|
s zCombine.ignorec C sP | ¡ }|d d
= |td | | j¡¡g| jd7 }| jrH| ¡ rH|gS |S d S )Nr» )r# )rl rA râ r~ r³ r÷ rë r[ )rÐ r½ rÌ r' ÚretToksr r r r( s
|
"zCombine.postParse)r» T)r r r rë rÒ r r( r× r r rÑ r 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 :class:`ZeroOrMore` and :class:`OneOrMore` expressions.
|
|
Example::
|
|
ident = Word(alphas)
|
num = Word(nums)
|
term = ident | num
|
func = ident + Optional(delimitedList(term))
|
print(func.parseString("fn a, b, 100")) # -> ['fn', 'a', 'b', '100']
|
|
func = ident + Group(Optional(delimitedList(term)))
|
print(func.parseString("fn a, b, 100")) # -> ['fn', ['a', 'b', '100']]
|
c s t t| |¡ d| _d S r )rÏ r/ rÒ rì r rÑ r r rÒ * s zGroup.__init__c C s |gS r© r r& r r r r( . s zGroup.postParse©r r r rë rÒ r( r× r r rÑ r r/ s c s( e Zd ZdZ fddZdd Z ZS )r) a? Converter to return a repetitive expression as a list, but also
|
as a dictionary. Each element can also be referenced using the first
|
token in the expression as its key. Useful for tabular report
|
scraping when the first column can be used as a item key.
|
|
Example::
|
|
data_word = Word(alphas)
|
label = data_word + FollowedBy(':')
|
attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
|
|
text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
|
attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
|
|
# print attributes as plain groups
|
print(OneOrMore(attr_expr).parseString(text).dump())
|
|
# instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
|
result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
|
print(result.dump())
|
|
# access named fields as dict entries, or output as dict
|
print(result['shape'])
|
print(result.asDict())
|
|
prints::
|
|
['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
|
[['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
|
- color: light blue
|
- posn: upper left
|
- shape: SQUARE
|
- texture: burlap
|
SQUARE
|
{'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
|
|
See more examples at :class:`ParseResults` of accessing fields by results name.
|
c s t t| |¡ d| _d S r )rÏ r) rÒ rì r rÑ r r rÒ X 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» r ) rü rÛ r r r¨ rã r rA rl r[ rë )rÐ r½ rÌ r' r ÚtokÚikeyÚ dictvaluer r r r( \ s$
|
zDict.postParserµ r r rÑ r r) 1 s & c @ s e Zd ZdZdd Zdd ZdS )rJ a[ Converter for ignoring the results of a parsed expression.
|
|
Example::
|
|
source = "a, b, c,d"
|
wd = Word(alphas)
|
wd_list1 = wd + ZeroOrMore(',' + wd)
|
print(wd_list1.parseString(source))
|
|
# often, delimiters that are useful during parsing are just in the
|
# way afterward - use Suppress to keep them out of the parsed output
|
wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
|
print(wd_list2.parseString(source))
|
|
prints::
|
|
['a', ',', 'b', ',', 'c', ',', 'd']
|
['a', 'b', 'c', 'd']
|
|
(See also :class:`delimitedList`.)
|
c C s g S r© r r& r r r r( s zSuppress.postParsec C s | S r© r rß r r r r s zSuppress.suppressN)r r r rë r( r r r r r rJ u s c @ s( e Zd ZdZdd Zdd Zdd ZdS ) r9 zDWrapper for parse actions, to ensure they are only called once.
|
c C s t || _d| _d S r¯ )rÈ r Úcalled)rÐ Ú
|
methodCallr r r rÒ s
|
zOnlyOnce.__init__c C s. | j s | |||¡}d| _ |S t||dd S )NTr» )r¹ r r> )rÐ r¯ r r r÷ r r r r s
|
zOnlyOnce.__call__c C s
|
d| _ d S r¯ )r¹ rß r r r Úreset s zOnlyOnce.resetN)r r r rë rÒ r r» r r r r r9 s c s: t fdd}z j|_W n tk
|
r4 Y nX |S )aq Decorator for debugging parse actions.
|
|
When the parse action is called, this decorator will print
|
``">> entering method-name(line:<current_source_line>, <parse_location>, <matched_tokens>)"``.
|
When the parse action completes, the decorator will print
|
``"<<"`` followed by the returned value, or any exception that the parse action raised.
|
|
Example::
|
|
wd = Word(alphas)
|
|
@traceParseAction
|
def remove_duplicate_chars(tokens):
|
return ''.join(sorted(set(''.join(tokens))))
|
|
wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
|
print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
|
|
prints::
|
|
>>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
|
<<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Ç r r Ú.z">>entering %s(line: '%s', %d, %r)
|
z <<leaving %s (exception: %s)
|
z<<leaving %s (ret: %r)
|
)r rÛ rÙ r¢ Ústderrr½ rg r° )ÚpaArgsÚthisFuncr¯ r r r§ r ©r r r Úz» s ztraceParseAction.<locals>.z)rÈ r r× )r rÁ r rÀ r r ¡ s ú,c 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 ``combine=True`` in the constructor. If
|
``combine`` is set to ``True``, the matching tokens are
|
returned as a single token string, with the delimiters included;
|
otherwise, the matching tokens are returned as a list of tokens,
|
with the delimiters suppressed.
|
|
Example::
|
|
delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
|
delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
|
z [rî r¡ N)r¨ r( rQ r rJ )r¾ ÚdelimÚcombineÚdlNamer r r r` Ñ 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 ``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$ rc )r¯ r r r ©Ú arrayExprr¾ r r ÚcountFieldParseActionþ s "z+countedArray.<locals>.countFieldParseActionNc S s t | d S r )r r r r r r r z countedArray.<locals>.<lambda>ÚarrayLenT©rú z(len) rÎ )r- rN rr r¤ rl r r r¨ )r¾ ÚintExprrÈ r rÆ r r\ æ s
|
c C s6 g }| D ](}t |tr&| t|¡ q| |¡ q|S r© )r r* rg rr r÷ )ÚLr§ r r r r rr
|
s
|
rr c s6 t fdd}| j|dd dt| ¡ S )a4 Helper to define an expression that is indirectly defined from
|
the tokens matched in a previous expression, that is, it looks for
|
a 'repeat' of a previous expression. For example::
|
|
first = Word(nums)
|
second = matchPreviousLiteral(first)
|
matchExpr = first + ":" + second
|
|
will match ``"1:1"``, but not ``"1:2"``. Because this
|
matches a previous literal, will also match the leading
|
``"1:1"`` in ``"1:10"``. If this is not desired, use
|
:class:`matchPreviousExpr`. Do *not* use with packrat parsing
|
enabled.
|
c sP |rBt |dkr |d > qLt| ¡ } tdd |D > n
|
t > d S )Nr¬ r c s s | ]}t |V qd S r© )r3 ©r Úttr r r r« * s zDmatchPreviousLiteral.<locals>.copyTokenToRepeater.<locals>.<genexpr>)rÛ rr r" r$ r+ )r¯ r r Útflat©Úrepr r ÚcopyTokenToRepeater# s z1matchPreviousLiteral.<locals>.copyTokenToRepeaterTrÊ ú(prev) )r- r r r¨ )r¾ rÒ r rÐ r ro s
|
|
c sF t | ¡ } |K fdd}| j|dd dt| ¡ S )aT Helper to define an expression that is indirectly defined from
|
the tokens matched in a previous expression, that is, it looks for
|
a 'repeat' of a previous expression. For example::
|
|
first = Word(nums)
|
second = matchPreviousExpr(first)
|
matchExpr = first + ":" + second
|
|
will match ``"1:1"``, but not ``"1:2"``. Because this
|
matches by expressions, will *not* match the leading ``"1:1"``
|
in ``"1:10"``; the expressions are evaluated first, and then
|
compared, so ``"1"`` is compared with ``"10"``. Do *not* use
|
with packrat parsing enabled.
|
c s* t | ¡ fdd}j|dd d S )Nc s$ t | ¡ }| kr tdddd S )Nr» r )rr r" r> )r¯ r r Ú theseTokens©Ú matchTokensr r ÚmustMatchTheseTokensE s zLmatchPreviousExpr.<locals>.copyTokenToRepeater.<locals>.mustMatchTheseTokensTrÊ )rr r" r¤ )r¯ r r r× rÐ rÕ r rÒ C s z.matchPreviousExpr.<locals>.copyTokenToRepeaterTrÊ rÓ )r- rl r r r¨ )r¾ Úe2rÒ r rÐ r rn 1 s c C s: dD ]}| |t| ¡} q| dd¡} | dd¡} t| S )Nz\^-[]rô r¹ r5 r8 )r² Ú_bslashr¨ )r¯ r¿ r r r r N s
|
r c sö t |trtjddd |r:dd }dd }|r4tnt n dd }dd }|rRtnt g }t | trn| ¡ }n$t | t rt
|
| }ntjd t dd |st S |s.d
|
}|t |d k r.|| }t||d d
D ]N\} }
|
||
|
|rú||| d = q¦qÔ|||
|
rÔ||| d = | ||
|
¡ q¦qÔ|d 7 }q¦|sÔ|sÔ|rÔzlt |t d |¡krtdd 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 :class:`MatchFirst` for best performance.
|
|
Parameters:
|
|
- strs - a string of space-delimited literals, or a collection of
|
string literals
|
- caseless - (default= ``False``) - treat all literals as
|
caseless
|
- useRegex - (default= ``True``) - as an optimization, will
|
generate a Regex object; otherwise, will generate
|
a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if
|
creating a :class:`Regex` raises an exception)
|
- asKeyword - (default=``False``) - enforce Keyword-style matching on the
|
generated expressions
|
|
Example::
|
|
comp_oper = oneOf("< = > <= >= !=")
|
var = Word(alphas)
|
number = Word(nums)
|
term = var | number
|
comparison_expr = term + comp_oper + term
|
print(comparison_expr.searchString("B = 12 AA=23 B<=AA AA>12"))
|
|
prints::
|
|
[['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
|
z_More than one string argument passed to oneOf, pass choices as a list or space-delimited stringr rz c S s | ¡ | ¡ kS r© )rç ©ro Úbr r r r { r zoneOf.<locals>.<lambda>c S s | ¡ | ¡ ¡S r© )rç r rÚ r r r r | r c S s | |kS r© r rÚ r r r r r c S s
|
| | ¡S r© r rÚ r r r r r z6Invalid argument to oneOf, expected string or iterabler r¬ Nr» r c s s | ]}t |V qd S r© )r ©r Úsymr r r r« £ s zoneOf.<locals>.<genexpr>rs ú|c s s | ]}t |¡V qd S r© )r r rÜ r r r r« ¥ s z7Exception creating Regex for oneOf, building MatchFirstc 3 s | ]} |V qd S r© r rÜ ©ÚparseElementClassr r r« « s )r r/ r~ r r% r& r0 r3 r° r
|
r* r r6 rÛ rü rc râ rF r r° r5 ) Ústrsræ ÚuseRegexr ÚisequalÚmasksÚsymbolsr ÚcurrC rm r rß r rs V s\
|
ÿ
|
|
|
|
ÿ
|
|
|
** ÿ 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 :class:`Dict`, :class:`ZeroOrMore`, and
|
:class:`Group` tokens in the proper order. The key pattern
|
can include delimiting markers or punctuation, as long as they are
|
suppressed, thereby leaving the significant key text. The value
|
pattern can include named results, so that the :class:`Dict` results
|
can include named token fields.
|
|
Example::
|
|
text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
|
attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
|
print(OneOrMore(attr_expr).parseString(text).dump())
|
|
attr_label = label
|
attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
|
|
# similar to Dict, but simpler call format
|
result = dictOf(attr_label, attr_value).parseString(text)
|
print(result.dump())
|
print(result['shape'])
|
print(result.shape) # object attribute access works too
|
print(result.asDict())
|
|
prints::
|
|
[['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
|
- color: light blue
|
- posn: upper left
|
- shape: SQUARE
|
- texture: burlap
|
SQUARE
|
SQUARE
|
{'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
|
)r) r8 r/ )ra rD r r r ra 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 ``asString`` argument is passed as
|
``False``, then the return value is
|
a :class:`ParseResults` containing any results names that
|
were originally matched, and a single token containing the original
|
matched text from the input string. So if the expression passed to
|
:class:`originalTextFor` contains expressions with defined
|
results names, you must set ``asString`` to ``False`` if you
|
want to preserve those results name values.
|
|
Example::
|
|
src = "this is test <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© r )r¯ rÌ r r r r r ñ r z!originalTextFor.<locals>.<lambda>FÚ_original_startÚ _original_endc S s | |j |j
S r© )rç rè rÁ r r r r ö r c S s& | | d¡| d¡
g|d d
< d S )Nrç rè )r` rÁ r r r Ú extractTextø s z$originalTextFor.<locals>.extractText)r+ r¤ rl rù rò )r¾ ÚasStringÚ locMarkerÚ endlocMarkerÚ matchExprré r r r r Ô s
|
|
c C s t | dd ¡S )zkHelper to undo pyparsing's default grouping of And expressions,
|
even if all but one are non-empty.
|
c S s | d S r r r r r r r r zungroup.<locals>.<lambda>)rL r )r¾ r r r r þ 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 ``<TAB>`` characters, you
|
may want to call :class:`ParserElement.parseWithTabs`
|
|
Example::
|
|
wd = Word(alphas)
|
for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
|
print(match)
|
|
prints::
|
|
[[0, 'ljsdf', 5]]
|
[[8, 'lksdjjf', 15]]
|
[[18, 'lkkjj', 23]]
|
c S s |S r© r rÁ r r r r r z locatedExpr.<locals>.<lambda>Ú
|
locn_startrD Úlocn_end)r+ r¤ r/ rl r )r¾ Úlocatorr r r r s z\[]-*.$+^?()~ ©r
|
c C s |d d S r; r rÁ r r r r ( r r z\\0?[xX][0-9a-fA-F]+c C s t t|d d¡dS )Nr z\0xrí )Úunichrr r¾ rÁ r r r r ) r z \\0[0-7]+c C s t t|d dd
dS )Nr r¬ é )rò r rÁ r r r r * r z\]rV rz rï Ú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 ``\-``
|
or ``\]``)
|
- an escaped hex character with a leading ``'\x'``
|
(``\x21``, which is a ``'!'`` character) (``\0x##``
|
is also supported for backwards compatibility)
|
- an escaped octal character with a leading ``'\0'``
|
(``\041``, which is a ``'!'`` character)
|
- a range of any of the above, separated by a dash (``'a-z'``,
|
etc.)
|
- any combination of the above (``'aeiouy'``,
|
``'a-zA-Z0-9_$'``, etc.)
|
c 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¾ r r r r« I s z+srange.<locals>.<lambda>.<locals>.<genexpr>r r¬ )r rA râ r< Úord)Úpr r r r I r zsrange.<locals>.<lambda>r» c 3 s | ]} |V qd S r© r )r Úpart©Ú _expandedr r r« K s zsrange.<locals>.<genexpr>N)râ Ú_reBracketExprrf rõ r° r r rú r r / s
|
"c s fdd}|S )zoHelper 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 %drH )r· Úlocnr r r r Ú verifyColS s z!matchOnlyAtCol.<locals>.verifyColr )r rþ r r r rm O s c s fddS )aµ Helper method for common parse actions that simply return
|
a literal value. Especially useful when used with
|
:class:`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© r rÁ ©ÚreplStrr r r e r z replaceWith.<locals>.<lambda>r rÿ r rÿ r r| X 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¬ r r rÁ r r r rz g s c sN fdd}zt dt dj}W n tk
|
rB t}Y nX ||_|S )aL 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
|
``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 :class:`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 r r )r Útokn©rÏ rÅ r r r s z(tokenMap.<locals>.pa.<locals>.<listcomp>r rÁ r r r rÇ s ztokenMap.<locals>.par rÙ )rÛ r r° r )rÅ rÏ rÇ rÞ r r r r v s $
|
ÿc C s t | ¡ S r© ©r¨ rç r r r r r ¦ r c C s t | ¡ S r© ©r¨ Úlowerr r r r r ª r r r c s~ t | tr | t| | d} n| j tttd }|rt ¡ t
|
¡}|| d t t t |td | tddgdd d d
|
¡ | }nlt ¡ t
|
¡ttd d B }|| d t t t | t¡ttd| tddgdd d d
|
¡ | }ttd| d dd}| d ¡ | fdd
|
¡ |dd dd¡ ¡ ¡ ¡ d ¡} |_ |_t | |_ ||fS )zRInternal helper to construct opening and closing tag expressions, given a tag namerì z_-:Útagú=ú/F©r\ rc c S s |d dkS ©Nr r r rÁ r r r r ¾ r z_makeTags.<locals>.<lambda>r rø c S s |d dkS r
|
r rÁ r r r r Æ r r )r² z<%s>c s* | dd dd¡ ¡ ¡ ¡ | ¡ ¡S )Nrñ r» ú:rî )r: râ r² Útitler° rl r ©Úresnamer r r Ì r r r» r rî z</%s>) r r/ r0 r! rN rT rS r^ rl r¤ rz r) rQ r/ rJ r: ry rv rb r( Ú_Lr r râ r² r r° r rG Útag_body)ÚtagStrÚxmlÚ suppress_LTÚ suppress_GTÚ tagAttrNameÚ tagAttrValueÚopenTagÚcloseTagr r r Ú _makeTags® sH
|
ÿþýüÿÿþüû, r c C s
|
t | dS )aK 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="https://github.com/pyparsing/pyparsing/wiki">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 -> https://github.com/pyparsing/pyparsing/wiki
|
F©r ©r r r r rk Ó 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 :class:`makeHTMLTags`
|
Tr r r r r rl ë s c s8 | r| dd
n| ¡ dd D fdd}|S )a7 Helper to create a validating parse action to be used with start
|
tags created with :class:`makeXMLTags` or
|
:class:`makeHTMLTags`. Use ``withAttribute`` to qualify
|
a starting tag with a required attribute value, to avoid false
|
matches on common tags such as ``<TD>`` or ``<DIV>``.
|
|
Call ``withAttribute`` with a series of attribute names and
|
values. Specify the list of filter attributes names and values as:
|
|
- keyword arguments, as in ``(align="right")``, or
|
- as an explicit dict with ``**`` operator, when an attribute
|
name is also a Python reserved word, as in ``**{"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 ``class`` (with or without a namespace), use
|
:class:`withClass`.
|
|
To verify that the attribute exists, but without specifying a value,
|
pass ``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 r r r r r r r / 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> r
Ú ANY_VALUE)r¯ r r0 ÚattrNameÚ attrValue©Úattrsr r rÇ 0 s ÿzwithAttribute.<locals>.pa)r? )rÏ ÚattrDictrÇ r r r r
ó s 8 c C s |r d| nd}t f || iS )aÉ Simplified version of :class:`withAttribute` when
|
matching on a div class - made difficult because ``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)r
)Ú classnameÚ namespaceÚ classattrr r r r : s #ú(r( c C s° G dd dt }t }| || | B }t|D ]r\}}|d dd
\} }
|
} } |
|
dk r`d| nd| } |
|
dkr| dkst| d krtd
|
| \}}t | ¡}| tjkrt|
|
d krÒ||| t|t | }n |
|
d kr*| dk r ||| | t|t | | }n ||| t|t | }nH|
|
dkrj||| | | | t|t || | | }ntd nì| tj
|
krX|
|
d krºt | t st | } || j | t| | }n|
|
d kr| dk rô||| | t|t | | }n ||| t|t | }nD|
|
dkrN||| | | | t|| | | | }ntd ntd | rt | ttfr|j| n
|
| | ¡ || | ¡|B K }|}q.||K }|S )al
|
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
|
:class:`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
|
``opAssoc.RIGHT`` and ``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
|
``setParseAction(*fn)``
|
(:class:`ParserElement.setParseAction`)
|
- lpar - expression for matching left-parentheses
|
(default= ``Suppress('(')``)
|
- rpar - expression for matching right-parentheses
|
(default= ``Suppress(')')``)
|
|
Example::
|
|
# simple example of four-function arithmetic with ints and
|
# variable names
|
integer = pyparsing_common.signed_integer
|
varname = pyparsing_common.identifier
|
|
arith_expr = 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]]]
|
c @ s e Zd ZdddZdS )zinfixNotation.<locals>._FBTc S s | j ||¡ |g fS r© )r¾ r6 r% r r r rñ s z$infixNotation.<locals>._FB.parseImplN)Trã r r r r Ú_FB¬ s r' r© Nr r z%s termz %s%s termr 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 r rt ÚLEFTr/ r8 ÚRIGHTr r: r¾ r r* r¤ )ÚbaseExprÚopListÚlparÚrparr' r§ ÚlastExprr ÚoperDefÚopExprÚarityÚrightLeftAssocrÇ ÚtermNameÚopExpr1ÚopExpr2ÚthisExprrí r r r r d s` Hÿ
|
|
&
|
ÿ
|
|
|
|
&
|
ÿ
|
|
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= ``"("``); can also be a pyparsing expression
|
- closer - closing character for a nested list
|
(default= ``")"``); can also be a pyparsing expression
|
- content - expression for items within the nested lists
|
(default= ``None``)
|
- ignoreExpr - expression for ignoring opening and closing
|
delimiters (default= :class:`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 ``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
|
:class:`Or` or :class:`MatchFirst`. The default is
|
:class:`quotedString`, but if no expressions are to be ignored, then
|
pass ``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ã r r r r r ; r z nestedExpr.<locals>.<lambda>c S s | d ¡ S r r: r r r r r @ r c S s | d ¡ S r r: r r r r r G r c S s | d ¡ S r r: r r r r r L r zOopening and closing arguments must be strings if no content expression is givenznested %s%s expression)r r r/ rÛ r( r8 r' rC rß r¤ rc rl r3 r- r/ rJ rQ r )ÚopenerÚcloserÚcontentr¤ r§ r r r rp ï s` A
|
ÿþþÿû
|
ÿþýÿþ ýü ÿ þý
|
*$c s& dd
fddfdd}fdd}fdd }t t d
|
¡ ¡ t d }t t |¡ d ¡}t |¡ d ¡}t |¡ d¡} |rÌtt || t |t| t | t d | }
|
n.tt |t |t| t | t d | }
|
|
|
|
fdd¡ | 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 current level; set to False for block of left-most
|
statements (default= ``True``)
|
|
A valid block must contain at least one ``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']]]]]]]
|
Nc s d d
< d S r© r r )Ú backup_stackÚ indentStackr r Ú reset_stackª s z"indentedBlock.<locals>.reset_stackc sN |t | krd S t|| }| d krJ| d kr>t| |dt| |dd S )Nr zillegal nestingznot a peer entry)rÛ rY r> ©r¯ r r ÚcurCol©r? r r ÚcheckPeerIndent s
|
z&indentedBlock.<locals>.checkPeerIndentc s2 t || }| d kr" |¡ n t| |dd S )Nr znot a subentry)rY r÷ r> rA rC r r ÚcheckSubIndentµ s
|
z%indentedBlock.<locals>.checkSubIndentc sJ |t | krd S t|| } r&| ks2t| |d| d k rF ¡ d S )Nznot an unindentr )rÛ rY r> r` rA rC r r Ú checkUnindent¼ s
|
z$indentedBlock.<locals>.checkUnindentz r ÚINDENTr» ÚUNINDENTc s S r© r )ro rÛ r¿ r )r@ r r r Ñ r z indentedBlock.<locals>.<lambda>zindented block) r8 r1 r r rH r+ r¤ r r/ r: r r rÙ ) ÚblockStatementExprr? r rD rE rF r§ rG ÚPEERÚUNDENTÚsmExprr )r> r? r@ r r W s2 Q ÿ þý ÿþz#[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]z[\0xa1-\0xbf\0xd7\0xf7]z_:zany tagzgt lt amp nbsp quot aposz><& "'z &(?P<entity>rÞ z);zcommon HTML entityc C s t | j¡S )zRHelper parser action to replace common HTML entities with their special characters)Ú_htmlEntityMaprþ Úentityr r r r 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 )?r a Here are some common low-level expressions that may be useful in
|
jump-starting parser development:
|
|
- numeric forms (:class:`integers<integer>`, :class:`reals<real>`,
|
:class:`scientific notation<sci_real>`)
|
- common :class:`programming identifiers<identifier>`
|
- network addresses (:class:`MAC<mac_address>`,
|
:class:`IPv4<ipv4_address>`, :class:`IPv6<ipv6_address>`)
|
- ISO8601 :class:`dates<iso8601_date>` and
|
:class:`datetime<iso8601_datetime>`
|
- :class:`UUID<uuid>`
|
- :class:`comma-separated list<comma_separated_list>`
|
|
Parse actions:
|
|
- :class:`convertToInteger`
|
- :class:`convertToFloat`
|
- :class:`convertToDate`
|
- :class:`convertToDatetime`
|
- :class:`stripHTMLTags`
|
- :class:`upcaseTokens`
|
- :class:`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 r r r r r r r ¤ r zpyparsing_common.<lambda>rV z"fraction or mixed integer-fractionz[+-]?(?:\d+\.\d*|\.\d+)z real numberz@[+-]?(?:\d+(?:[eE][+-]?\d+)|(?:\d+\.\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 r )r Ú
|
_ipv6_partrl rÍ r r r r« Ä s z,pyparsing_common.<lambda>.<locals>.<genexpr>ró )r~ r r r r 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= ``"%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 r Úve©Úfmtr r Úcvt_fnÞ s z.pyparsing_common.convertToDate.<locals>.cvt_fnr ©r^ r_ r r] r Ú 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= ``"%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 rY r r> r r[ r] r r r_ ÷ s z2pyparsing_common.convertToDatetime.<locals>.cvt_fnr r` r r] r Ú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="https://github.com/pyparsing/pyparsing/wiki">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)
|
|
Prints::
|
|
More info at the pyparsing wiki page
|
r )r Ú_html_stripperr¥ )r¯ r r0 r r r Ú stripHTMLTags s z pyparsing_common.stripHTMLTagsr rø rO rP r» r zcomma separated listc C s t | ¡ S r© r r r r r r # r c C s t | ¡ S r© r r r r r r & r N)rX )rb )?r r r rë r r ÚconvertToIntegerÚfloatÚconvertToFloatrN rr r r¤ rQ rd rU rF Úsigned_integerrR r r: r Ú mixed_integerr~ ÚrealÚsci_realra ÚnumberrS rT rS rT Ú ipv4_addressrW Ú_full_ipv6_addressÚ_short_ipv6_addressr Ú_mixed_ipv6_addressr( Ú ipv6_addressÚ mac_addressr ra rc Ú iso8601_dateÚiso8601_datetimeÚuuidrW rV re rf r8 r3 r1 rv rM Ú _commasepitemr` ry rl Úcomma_separated_listr rb r r r r r þ sv ""
|
ÿþý
|
ÿ
|
þ
|
ý ý
|
ÿÿþc @ s e Zd Zdd Zdd ZdS )Ú_lazyclasspropertyc C s || _ |j| _|j| _d S r© )rÅ rë r r r r r rÒ + s z_lazyclassproperty.__init__c sl d krt | t dr:t fdd jdd
D r@i _| jj}| jkrb| ¡ j|< j| S )NÚ_internc 3 s | ]} j t|d g kV qdS )r{ N)r{ rÛ )r Ú
|
superclassrä r r r« 3 s ÿz-_lazyclassproperty.__get__.<locals>.<genexpr>r¬ )ré rQ r¦ Ú__mro__r{ rÅ r )rÐ r¦ rÓ Úattrnamer rä r Ú__get__0 s ÿ
|
z_lazyclassproperty.__get__N)r r r rÒ r r r r r rz * s rz c @ sP e Zd ZdZg Zedd Zedd Zedd Z edd Z
|
ed
|
d Z d S ) r a×
|
A set of Unicode characters, for language-specific strings for
|
``alphas``, ``nums``, ``alphanums``, and ``printables``.
|
A unicode_set is defined by a list of ranges in the Unicode character
|
set, in a class attribute ``_ranges``, such as::
|
|
_ranges = [(0x0020, 0x007e), (0x00a0, 0x00ff),]
|
|
A unicode set can also be defined using multiple inheritance of other unicode sets::
|
|
class CJK(Chinese, Japanese, Korean):
|
pass
|
c C sZ g }| j D ]8}|tkr qD|jD ] }| t|d |d d ¡ q q
|
dd tt|D S )Nr r r¬ c S s g | ] }t |qS r rö r¾ r r r r T s z5unicode_set._get_chars_for_ranges.<locals>.<listcomp>)r} r Ú_rangesrg r< r¤ rû )rÓ r§ ÚccÚrrr r r Ú_get_chars_for_rangesL s
|
|
z!unicode_set._get_chars_for_rangesc C s d ttj| ¡ ¡S )z+all non-whitespace characters in this ranger» )râ r r rG r rä r r r rv V s zunicode_set.printablesc C s d ttj| ¡ ¡S )z'all alphabetic characters in this ranger» )râ Úfilterr Úisalphar rä r r r rT [ s zunicode_set.alphasc C s d ttj| ¡ ¡S )z*all numeric digit characters in this ranger» )râ r r Úisdigitr rä r r r rr ` s zunicode_set.numsc C s | j | j S )z)all alphanumeric characters in this range)rT rr rä r r r rS e s zunicode_set.alphanumsN) r r r rë r rì r rz rv rT rr rS r r r r r < s
|
|
|
|
c @ sð e Zd ZdZdejfgZG dd deZG dd deZ G dd deZ
|
G d d
|
d
|
eZ G d d d eZ G d d deZ G dd deZG dd deZG dd de eeZG dd deZG dd deZG dd deZG dd d eZd S ) r zF
|
A namespace class for defining common language unicode_sets.
|
é c @ s e Zd ZdZddgZdS )zpyparsing_unicode.Latin1z/Unicode set for Latin-1 Unicode Character Range)r é~ )é éÿ N©r r r rë r r r r r ÚLatin1q s r c @ s e Zd ZdZdgZdS )zpyparsing_unicode.LatinAz/Unicode set for Latin-A Unicode Character Range)é i Nr r r r r ÚLatinAu s r c @ s e Zd ZdZdgZdS )zpyparsing_unicode.LatinBz/Unicode set for Latin-B Unicode Character Range)i iO Nr r r r r ÚLatinBy s r c @ s6 e Zd ZdZdddddddd d
|
d d d dddddgZdS )zpyparsing_unicode.Greekz.Unicode set for Greek Unicode Character Ranges)ip iÿ )i i )i i )i iE )iH iM )iP iW )iY )i[ )i] )i_ i} )i i´ )i¶ iÄ )iÆ iÓ )iÖ iÛ )iÝ iï )iò iô )iö iþ Nr r r r r ÚGreek} s& ýr c @ s e Zd ZdZdgZdS )zpyparsing_unicode.Cyrillicz0Unicode set for Cyrillic Unicode Character Range)i iÿ Nr r r r r ÚCyrillic
s r c @ s e Zd ZdZddgZdS )zpyparsing_unicode.Chinesez/Unicode set for Chinese Unicode Character Range)é N iÿ ©i 0 i?0 Nr r r r r ÚChinese s r c @ sD e Zd ZdZg ZG dd deZG dd deZG dd deZdS ) zpyparsing_unicode.Japanesez`Unicode set for Japanese Unicode Character Range, combining Kanji, Hiragana, and Katakana rangesc @ s e Zd ZdZddgZdS )z pyparsing_unicode.Japanese.Kanjiz-Unicode set for Kanji Unicode Character Range)r i¿ r Nr r r r r ÚKanji s r c @ s e Zd ZdZdgZdS )z#pyparsing_unicode.Japanese.Hiraganaz0Unicode set for Hiragana Unicode Character Range)i@0 i0 Nr r r r r ÚHiragana s r c @ s e Zd ZdZdgZdS )z#pyparsing_unicode.Japanese.Katakanaz1Unicode set for Katakana Unicode Character Range)i 0 iÿ0 Nr r r r r ÚKatakana s r N) r r r rë r r r r r r r r r ÚJapanese s
|
r c @ s e Zd ZdZddddddgZdS ) zpyparsing_unicode.Koreanz.Unicode set for Korean Unicode Character Range)i ¬ i¯× )i iÿ )i01 i1 )i`© i© )i°× iÿ× r Nr r r r r ÚKorean s r c @ s e Zd ZdZdS )zpyparsing_unicode.CJKzTUnicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character RangeNr r r r r ÚCJK¡ s r c @ s e Zd ZdZddgZdS )zpyparsing_unicode.Thaiz,Unicode set for Thai Unicode Character Range)i i: )i? i[ Nr r r r r ÚThai¥ s r c @ s e Zd ZdZdddgZdS )zpyparsing_unicode.Arabicz.Unicode set for Arabic Unicode Character Range)i i )i iÿ )i i Nr r r r r ÚArabic© s r c @ s e Zd ZdZdgZdS )zpyparsing_unicode.Hebrewz.Unicode set for Hebrew Unicode Character Range)i iÿ Nr r r r r ÚHebrew s r c @ s e Zd ZdZddgZdS )z pyparsing_unicode.Devanagariz2Unicode set for Devanagari Unicode Character Range)i i )iਠiÿ¨ Nr r r r r Ú
|
Devanagari± s r N)r r r rë r¢ Ú
|
maxunicoder r r r r r r r r r r r r r r r r r r r k s u اÙعربÙØ©u ä¸æu киÑиллиÑаu Îλληνικάu ×¢Ö´×רִ×תu æ¥æ¬èªu æ¼¢åu ã«ã¿ã«ãu ã²ãããªu íêµì´u à¹à¸à¸¢u दà¥à¤µà¤¨à¤¾à¤à¤°à¥c @ s, e Zd ZdZG dd dZG dd dZdS )Úpyparsing_testzB
|
namespace class for classes useful in writing unit tests
|
c @ s8 e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd S ) z&pyparsing_test.reset_pyparsing_contextax
|
Context manager to be used when writing unit tests that modify pyparsing config values:
|
- packrat parsing
|
- default whitespace characters.
|
- default keyword characters
|
- literal string auto-conversion class
|
- __diag__ settings
|
|
Example:
|
with reset_pyparsing_context():
|
# test that literals used to construct a grammar are automatically suppressed
|
ParserElement.inlineLiteralsUsing(Suppress)
|
|
term = Word(alphas) | Word(nums)
|
group = Group('(' + term[...] + ')')
|
|
# assert that the '()' characters are not included in the parsed tokens
|
self.assertParseAndCheckLisst(group, "(abc 123 def)", ['abc', '123', 'def'])
|
|
# after exiting context manager, literals are converted to Literal expressions again
|
c C s
|
i | _ d S r© )Ú _save_contextrß r r r rÒ å s z/pyparsing_test.reset_pyparsing_context.__init__c C sf t j| jd< tj| jd< t j| jd< t j| jd< t j| jd< dd tj D | jd< d t
|
j i| jd
|
< | S ) NÚdefault_whitespaceÚdefault_keyword_charsÚliteral_string_classÚpackrat_enabledÚ packrat_parsec S s i | ]}|t t|qS r )rÛ r )r r! r r r Ú
|
<dictcomp>ð s z?pyparsing_test.reset_pyparsing_context.save.<locals>.<dictcomp>r rd r# ) rC rß r¡ r0 rå rã r^ r r Ú
|
_all_namesr# rd rß r r r Úsaveè s þÿ ÿ ÿ
|
z+pyparsing_test.reset_pyparsing_context.savec C s t j| jd kr t | jd ¡ | jd t_t | jd ¡ | jd ¡ D ]\}}tt || qJ| jd t _
|
| jd t _ | jd t _ d S )Nr¢ r£ r¤ r r¥ r¦ r# )rC rß r¡ râ r0 rå rå r? Úsetattrr r^ r r# rd )rÐ r! rD r r r Úrestoreø s ÿÿÿ ÿ z.pyparsing_test.reset_pyparsing_context.restorec C s | ¡ S r© )r© rß r r r Ú __enter__ s z0pyparsing_test.reset_pyparsing_context.__enter__c G s | ¡ S r© )r« rÖ r r r Ú__exit__ s z/pyparsing_test.reset_pyparsing_context.__exit__N) r r r rë rÒ r© r« r¬ r r r r r Úreset_pyparsing_contextÎ s r® c @ sJ e Zd ZdZdddZdddZddd Zdd
|
d Zee dfd d Z
|
dS )z&pyparsing_test.TestParseResultsAssertszk
|
A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
|
Nc C s< |dk r | j || ¡ |d |dk r8| j || ¡ |d dS )zÀ
|
Unit test assertion to compare a ParseResults object with an optional expected_list,
|
and compare any defined results names with an optional expected_dict.
|
N©rÆ )Ú assertEqualr" r )rÐ rÊ Ú expected_listÚ expected_dictrÆ r r r ÚassertParseResultsEquals s z?pyparsing_test.TestParseResultsAsserts.assertParseResultsEqualsTc C s2 |j |dd}|r t| ¡ | j|||d dS )z¾
|
Convenience wrapper assert to test a parser element and input string, and assert that
|
the resulting ParseResults.asList() is equal to the expected_list.
|
Tr¶ )r± rÆ N©rf r¼ r¥ r³ )rÐ r¾ Ú test_stringr± rÆ ÚverboserÊ r r r ÚassertParseAndCheckList! s z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckListc C s2 |j |dd}|r t| ¡ | j|||d dS )z¾
|
Convenience wrapper assert to test a parser element and input string, and assert that
|
the resulting ParseResults.asDict() is equal to the expected_dict.
|
Tr¶ )r² rÆ Nr´ )rÐ r¾ rµ r² rÆ r¶ rÊ r r r ÚassertParseAndCheckDict- s z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDictc
|
C s
|
|\}}|dk rìdd t ||D }|D ]Â\}}} tdd | D d}
|
tdd | D d} | dk r| j| |
|
pn|d t|tr|W 5 Q R X q(tdd | D d} td d | D d} | | fd
|
krÜ| j|| | |
|
pÔ|d q(td |¡ q(| j||dk rþ|nd d dS )aP
|
Unit test assertion to evaluate output of ParserElement.runTests(). If a list of
|
list-dict tuples is given as the expected_parse_results argument, then these are zipped
|
with the report tuples returned by runTests and evaluated using assertParseResultsEquals.
|
Finally, asserts that the overall runTests() success value is True.
|
|
:param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests
|
:param expected_parse_results (optional): [tuple(str, list, dict, Exception)]
|
Nc S s" g | ]\}}|d |d |fqS rq r )r ÚrptÚexpectedr r r r H s ÿzOpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<listcomp>c s s | ]}t |tr|V qd S r© )r r ©r Úexpr r r r« Q s
|
zNpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<genexpr>c s s& | ] }t |trt|tr|V qd S r© )r ré r r° r» r r r r« T s
|
|
þ)Úexpected_exceptionrÆ c s s | ]}t |tr|V qd S r© )r r* r» r r r r« c s
|
c s s | ]}t |tr|V qd S r© )r r- r» r r r r« f s
|
r )r± r² rÆ zno validation for {!r}zfailed runTestsr¯ ) r± r Ú assertRaisesr r° r³ r¼ rø Ú
|
assertTrue)rÐ Úrun_tests_reportÚexpected_parse_resultsrÆ Úrun_test_successÚrun_test_resultsÚmergedrµ rÊ rº Úfail_msgr½ r± r² r r r ÚassertRunTestResults9 sV þ ÿþú ÿ
|
ÿ ÿ ü ÿz;pyparsing_test.TestParseResultsAsserts.assertRunTestResultsc c s$ | j ||d d V W 5 Q R X d S )Nr¯ )r¾ )rÐ rÄ rÆ r r r ÚassertRaisesParseExceptionx s zApyparsing_test.TestParseResultsAsserts.assertRaisesParseException)NNN)NT)NT)NN) r r r rë r³ r· r¸ rÆ r r> rÇ r r r r ÚTestParseResultsAsserts s ÿ
|
ÿ
|
ÿ
|
ÿ
|
?rÈ N)r r r rë r® rÈ r r r r r É s Cr Ú__main__ÚselectÚfromrä r¼ )rÄ Ú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
|
)NF)r )r F)N)FTF)T)r» )T( rë r r! r" r¼ Úweakrefr r7 rl r¢ r~ r r rS r¨ rÌ rB r Úoperatorr Ú itertoolsÚ functoolsr Ú
|
contextlibr r Ú ImportErrorr Ú_threadr Ú threadingÚcollections.abcr
|
r r r rM Z ordereddictr r# rd r r r r r rþ r¯ r¨ r Úenable_all_warningsÚ__all__r Ú version_inforË r ÚmaxsizerÍ r r/ Úchrrò r r¨ r~ rÛ r¤ Úreversedr* rû r¦ r r r rÚ ZmaxintÚxranger< Ú __builtin__r° Úfnamer÷ rÛ r× ré r, r¸ Úascii_uppercaseÚascii_lowercaserT rr rd rS rÙ râ Ú printablerv r r° r< r> r@ rB rE r r rA ÚregisterrY rj rg r¿ rà rÄ rq rÈ rC r} rK r+ r6 r3 rà r rã r0 r& r% r rN r rR rF rD r' rM rD r. r2 r1 rI rH rP rO r? r$ r; r5 r* r= r, r4 r7 r r8 rQ r¢ r: rG r- rL r( r/ r) rJ r9 r r` r\ rr ro rn r rs ra r r r r rc ri rh r r r¤ Ú _escapedPuncÚ_escapedHexCharÚ_escapedOctCharÚ _singleCharÚ
|
_charRanger rü r rm r| rz r r rb r rk rl r
r r rt r( r) r ru r^ r~ ry r rp r rU rw rW rV r- r± rM rW r[ r{ rX re r r} r_ r] rf rx ra rx rZ r rz r r r r r r r rª r r r r r r r r r r Z selectTokenZ fromTokenÚidentZ
|
columnNameZcolumnNameListZ
|
columnSpecZ tableNameZ tableNameListZ simpleSQLrÌ rn rS rU rw rd r r r r Ú<module> s* ÿH
|
í
|
?]
|
|
H
|
|
D +!
|
'N E
|
KF ym{V O#K,:# Dvj-D 0 $ W' * :
|
|
|
|
|
0þ%
|
|
|
E& ÿÿ h~
|
|
(
|
|
ÿÿÿ þ ./Jÿþ 6 ,
|
|
