core.pyc
1 o 2 ���c>A � @ s� U d dl Z d dlZd dlmZmZmZmZmZmZmZm Z m 3 Z 4 m Z d dl m Z mZ d dlmZ d dlZd dlZd dlZd dlZd dlZd dlmZ d dlZd dlZd dlmZ d dl m Z d dl m Z d d l m!Z! d 5 d l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z+m,Z- d 6 d l.T d 7 d l/T d 8 d l0m1Z1m2Z2 d 9 dl3m4Z4 ej5Z6e7e8fZ9ee:df e;d< ej<dkr�d dl m=Z= nG dd� d�Z=G dd� de%�Z>G dd� de%�Z?G dd� de�Z@de@d dfd d �ZAde@d dfd d �ZBd�d!d"�ZC[%d#eje7 d$ejDe7 d eEfd%d&�ZFeFejGe jH�Id'���reC� eJeKeLeMeNeOePeQeReSeTh ZUejVZWeeg ef ee1gef eeXe1gef ee7eXe1gef f ZYeeg eEf ee1geEf eeXe1geEf ee7eXe1geEf f ZZee7eXd(e[gdf Z\ee7eXd(eEgdf Z]ee7eXeXd(e1eEgdf Z^ee7eXd(e[eEgdf Z_ej`eja Zbe4jcjdZde4jcjeZed)Zfefd* Zgebef Zhd+�id,d-� ejjD ��Zkdalejme;d.< d�d0d1�Zn 2d�d3eZd4e7d5eEd eYfd6d7�Zo 2d�d8e7d9eXd:d(d;eEfd<d=�Zp 2d�d8e7d>eXd?eXd:d(d@e1d;eEf dAdB�Zq 2d�d8e7d9eXd:d(dCe[d;eEf 10 dDdE�ZrdFdG� ZsG dHd(� d(e �ZtG dIdJ� dJet�ZuG dKdL� dLet�ZvG dMdN� dNev�ZwG dOdP� dPev�ZxG dQdR� dRev�ZyG dSdT� dTey�Zzeyet_{G dUdV� dVev�Z|G dWdX� dXey�Z}G dYdZ� dZe|�Z~G d[d\� d\ev�ZG d]d^� d^ev�Z�G d_d`� d`e��Z�G dadb� dbe��Z�G dcdd� ddev�Z�G dedf� dfev�Z�G dgdh� dhev�Z�G didj� djev�Z�G dkdl� dlev�Z�G dmdn� dne��Z�G dodp� dpe��Z�G dqdr� dre��Z�G dsdt� dte��Z�G dudv� dve��Z�G dwdx� dxe��Z�G dydz� dze��Z�G d{d|� d|et�Z�G d}d~� d~e��Z�G dd�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�et�Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d��Z�G d�d�� d�e��Z�e�ZDG d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�d�eYd eYfd�d��Z�ew� ��d��Z�e�� ��d��Z�e�� ��d��Z�e�� ��d��Z�e�� ��d��Z�e�e(d�d�d����d�d�� �Z�e�d����d�d�� �Z�e�d����d�d�� �Z�e�e�B e�B e�d�d 11 d��B Z�e�e�e�d�� e� �Z�eyd��e�d����d¡ e�e�e�e�B ����dá d� Z�d�e7d e7fd�dDŽZ�d eYfd�dɄZ�d�d�d˄Z�e�e�d̃d� ���dΡZ�e�e�dσd� ���dѡZ�e�e�d̃d� e�dσd� B ���dҡZ�e�d�e��� ���dԡZ�e�dՃZ�e�dփZ�d�d-� e�� ��� D �Z�eet e;d�< e�Z�eoZ�esZ�e�Z�e�Z�e�Z�e�Z�e�Z�e�Z�e�Z�e�Z�e�Z�dS )�� N) 12 � 13 NamedTuple�Union�Callable�Any� Generator�Tuple�List�TextIO�Set�Sequence)�ABC�abstractmethod)�Enum)�Iterable)� 14 itemgetter)�wraps)�RLock)�Path� ) � 15 _FifoCache�_UnboundedCache�__config_flags�_collapse_string_to_ranges�_escape_regex_range_chars�_bslash�_flatten�LRUMemo� UnboundedMemo)�*)� ParseResults�_ParseResultsWithOffset)�pyparsing_unicode.�str_type)� � )�cached_propertyc @ s e Zd Zdd� Zddd�ZdS )r% c C s 16 || _ d S �N)�_func)�self�func� r* ��C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.10_3.10.2800.0_x64__qbz5n2kfra8p0\lib\site-packages\setuptools\_vendor\pyparsing\core.py�__init__Q � 17 zcached_property.__init__Nc C s | � |� }|j| j j< |S r& )r' �__dict__�__name__)r( �instance�owner�retr* r* r+ �__get__T s zcached_property.__get__r& )r/ � 18 __module__� __qualname__r, r3 r* r* r* r+ r% P s r% c @ s0 e Zd ZdZdZdZdd� e� D �Zd�� Z dS )� 19 __compat__aJ 20 A cross-version compatibility configuration for pyparsing features that will be 21 released in a future version. By setting values in this configuration to True, 22 those features can be enabled in prior versions for compatibility development 23 and testing. 24 25 - ``collect_all_And_tokens`` - flag to enable fix for Issue #63 that fixes erroneous grouping 26 of results names when an :class:`And` expression is nested within an :class:`Or` or :class:`MatchFirst`; 27 maintained for compatibility, but setting to ``False`` no longer restores pre-2.3.1 28 behavior 29 � compatibilityTc C � g | ] }|� d �s|�qS ��_�� 30 startswith��.0�__r* r* r+ � 31 <listcomp>j � z__compat__.<listcomp>z( 32 collect_all_And_tokens 33 N) 34 r/ r4 r5 �__doc__� 35 _type_desc�collect_all_And_tokens�locals� 36 _all_names�split� _fixed_namesr* r* r* r+ r6 Y s �r6 c @ sj e Zd ZdZdZdZdZdZdZdZ dZ 37 dZ dd� e � D �Z dd� e D �Zdd� e D �Zed d d 38 ��ZdS ) �__diag__� 39 diagnosticFc C r8 r9 r; r= r* r* r+ r@ | rA z__diag__.<listcomp>c C � g | ] }|� d �r|�qS )�warnr; �r> �namer* r* r+ r@ } rA c C rK )� enable_debugr; rM r* r* r+ r@ ~ rA �returnNc C s | j D ]}| �|� qd S r& )�_warning_names�enable)�clsrN r* r* r+ �enable_all_warnings� s 40 �z __diag__.enable_all_warnings�rP N)r/ r4 r5 rC �)warn_multiple_tokens_in_named_alternation�)warn_ungrouped_named_tokens_in_collection� warn_name_set_on_empty_Forward�!warn_on_parse_using_empty_Forward� warn_on_assignment_to_Forward�%warn_on_multiple_string_args_to_oneof�(warn_on_match_first_with_lshift_operator�!enable_debug_on_named_expressionsrE rF rQ � _debug_names� classmethodrT r* r* r* r+ rI p s rI c @ s0 e Zd ZdZdZdZdZdZdZdZ dZ 41 d Z d 42 S ) � Diagnosticsa� 43 Diagnostic configuration (all default to disabled) 44 - ``warn_multiple_tokens_in_named_alternation`` - flag to enable warnings when a results 45 name is defined on a :class:`MatchFirst` or :class:`Or` expression with one or more :class:`And` subexpressions 46 - ``warn_ungrouped_named_tokens_in_collection`` - flag to enable warnings when a results 47 name is defined on a containing expression with ungrouped subexpressions that also 48 have results names 49 - ``warn_name_set_on_empty_Forward`` - flag to enable warnings when a :class:`Forward` is defined 50 with a results name, but has no contents defined 51 - ``warn_on_parse_using_empty_Forward`` - flag to enable warnings when a :class:`Forward` is 52 defined in a grammar but has never had an expression attached to it 53 - ``warn_on_assignment_to_Forward`` - flag to enable warnings when a :class:`Forward` is defined 54 but is overwritten by assigning using ``'='`` instead of ``'<<='`` or ``'<<'`` 55 - ``warn_on_multiple_string_args_to_oneof`` - flag to enable warnings when :class:`one_of` is 56 incorrectly called with multiple str arguments 57 - ``enable_debug_on_named_expressions`` - flag to auto-enable debug on all subsequent 58 calls to :class:`ParserElement.set_name` 59 60 Diagnostics are enabled/disabled by calling :class:`enable_diag` and :class:`disable_diag`. 61 All warnings can be enabled by calling :class:`enable_all_warnings`. 62 r r � r# � � � � N) r/ r4 r5 rB rV rW rX rY rZ r[ r\ r] r* r* r* r+ r` � s r` � diag_enumrP c C � t �| j� dS )zO 63 Enable a global pyparsing diagnostic flag (see :class:`Diagnostics`). 64 N)rI rR rN �rf r* r* r+ � enable_diag� � ri c C rg )zP 65 Disable a global pyparsing diagnostic flag (see :class:`Diagnostics`). 66 N)rI �disablerN rh r* r* r+ � disable_diag� rj rl c C s t �� dS )zU 67 Enable all global pyparsing diagnostic warnings (see :class:`Diagnostics`). 68 N)rI rT r* r* r* r+ rT � s rT �cmd_line_warn_options� warn_env_varc C sx t |�}| D ]3}|d �d�d d� \}}}}}|�� �d�s,|s%|s%|r)|dkr,d}q|�� �d�r9|dv r9d}q|S ) Nz::::�:rc �i� pyparsingT)rq � F)�boolrG �lowerr< ) rm rn rR �warn_opt�w_action� w_message� 69 w_category�w_module�w_liner* r* r+ �_should_enable_warnings� s( ������r{ �PYPARSINGENABLEALLWARNINGS� ParserElement� 70 0123456789� ABCDEFabcdefrr c C s g | ] }|t jvr|�qS r* )�string� 71 whitespace�r> �cr* r* r+ r@ rA r@ �_trim_arity_call_liner# c s� �t v r 72 �fdd�S d�d�ddd�� d}tp tjdd �d 73 atd td | f�� �����fd d �}t�dt�d�j�}||_�j|_|S )zAdecorator to trim function calls to match the arity of the targetc s � |�S r& r* ��s�l�t)r) r* r+ �<lambda> � z _trim_arity.<locals>.<lambda>r Fc S s$ t j| |d�}|d }|d d� gS )N��limit�����ra )� traceback� 74 extract_tb)�tbr� �frames� frame_summaryr* r* r+ r� s z _trim_arity.<locals>.extract_tbre ra r� r� r c 75 s� z �| �d � � }d�|W S t y@ } z&�r� |j}� |dd�d d d� �k}~|r;��k r;�d7 �W Y d }~q � d }~ww )Nr Tra r� r� )� TypeError� __traceback__)�argsr2 �ter� �trim_arity_type_error�r� � found_arityr) r� � max_limit�pa_call_line_synthr* r+ �wrapper s& � ��z _trim_arity.<locals>.wrapperr/ � __class__N�r )�_single_arg_builtinsr� r� � extract_stack�getattrr/ rB )r) r� � LINE_DIFFr� � func_namer* r� r+ � _trim_arity s 76 r� F�fn�message�fatalc s@ |dur|nd�|r t nt� t���t��� ��fdd��}|S )aC 77 Function to convert a simple predicate function that returns ``True`` or ``False`` 78 into a parse action. Can be used in places when a parse action is required 79 and :class:`ParserElement.add_condition` cannot be used (such as when adding a condition 80 to an operator level in :class:`infix_notation`). 81 82 Optional keyword arguments: 83 84 - ``message`` - define a custom message to be used in the raised exception 85 - ``fatal`` - if True, will raise :class:`ParseFatalException` to stop parsing immediately; 86 otherwise will raise :class:`ParseException` 87 88 Nz failed user-defined conditionc s t �| ||��s� | |���d S r& )rs r� ��exc_typer� �msgr* r+ �paV s �z%condition_as_parse_action.<locals>.pa)�ParseFatalException�ParseExceptionr� r )r� r� r� r� r* r� r+ �condition_as_parse_actionB s r� �instring�loc�expr� cache_hitc C sJ |rdnd}t d�|||t|| �t|| �t|| �dt|| �d �� d S )Nr rr z&{}Match {} at loc {}({},{}) 89 {} 90 {}^� r )�print�format�lineno�col�line)r� r� r� r� � cache_hit_strr* r* r+ �_default_start_debug_action^ s ��r� �startloc�endloc�toksc C s& |rdnd}t d�|||�� �� d S )Nr rr z{}Matched {} -> {})r� r� �as_list)r� r� r� r� r� r� r� r* r* r+ � _default_success_debug_actionq s r� �excc C s* |rdnd}t d�||t|�j|�� d S )Nr rr z {}Match {} failed, {} raised: {})r� r� �typer/ )r� r� r� r� r� r� r* r* r+ � _default_exception_debug_action} s ��r� c G � dS )zG'Do-nothing' debug action, to suppress debugging output during parsing.Nr* )r� r* r* r+ �null_debug_action� � r� c ' @ s� e Zd ZU dZdZeed< dZeed< dZ e 91 j e ed< e ded dfd 92 d ��Ze d e d dfd d��ZG dd� de�Zd�defdd�Zded d fdd�Zd�dd�Z d�dd�deded ed d fd d �Zd�d d �Zd�d"ed d fd#d$�Zd%ed d fd&d'�Zd%ed d fd(d)�Zd%e d d fd*d+�Z d,e d d fd-d.�Z d/d0� Z d1d2� Z!d�d3d4�Z"d5d6� Z# !d�d e$e%e&f fd7d8�Z'd�d9ed:e%d;ed e%fd<d=�Z(d9ed:e%d efd>d?�Z)e*� Z+i Z,e 93 j-e$e%d@ef e$e%e.e&e/f f f edA< i Z0e*� Z1dBdBgZ2 !d�d e$e%e&f fdCdD�Z3e'Z4e d�dEdF��Z5dZ6dZ7e d�dGdH��Z8e d�ddI�dJe 94 j e% d dfdKdL��Z9e d�ddI�dJe%dNed dfdOdP��Z: d�ddQ�d9edRedSed e&fdTdU�Z;e<dfde<dV�d9edWe%dXedYedZe%d e=e$e&e%e%f ddf f d[d\�Z>dd]�d9edYed efd^d_�Z?e<fde<dV�d9edWe%dYedZe%d e&f 95 d`da�Z@e<dfddb�d9edce%dded e=eddf fdedf�ZAd�dgdh�ZBd�didj�ZCd�dkdl�ZDd�dmdn�ZEd�dodp�ZFd�dqdr�ZGd�dsdt�ZHd�dudv�ZId�dwdx�ZJd�dydz�ZKd�d{d|�ZLd�d}d~�ZMd�dd��ZNdZOd�d�� ZPd�ded d fd�d��ZQd�d�d��ZRd�d�ed d fd�d��ZSd�d�ed d fd�d��ZT d�de.eUe ef d�ed d fd�d��ZVd�d�d��ZWd�d�d��ZXd�eYd�eZd�e[d d fd�d��Z\d�d�ed d fd�d��Z]e^d efd�d���Z_e`d�d�� �Zaded d fd�d��Zbe^d efd�d���Zcd efd�d��Zdd efd�d��Zed�d�d��Zfd egd fd�d��Zhd�d�� Zid�d�d�d��Zj � d�ddQ�d�e.eekelf d�edRedSed e&f 96 d�d��Zmd�d�� Znd�d�� Zo !d�d!dQ�d�edRedSed efd�d��Zp ! � ! ! d�d!d!d!ddd��d�e.eeqe f dRed�e 97 j e.d ef d�ed�ed�ed�eree&gef d�e 98 j el d�edSed�ed�ed�ed�eree&gef d e$eeqe$ee.e&e/f f f f d�d˄Zs � d�d�e.elekef d�e%d�ed�ed df 99 d�d҄ZteZueZveZweZxeZyeZze Z{e Z|e(Z}e)Z~e5Ze9Z�e:Z�e;Z�e>Z�e@Z�e?Z�eVZ�eWZ�e\Z�e]Z�e_Z�ebZ�emZ�esZ�eSZ�eTZ�dS )�r} z)Abstract base level parser element class.z 100 �DEFAULT_WHITE_CHARSF�verbose_stacktraceN�_literalStringClass�charsrP c C s$ | t _tD ] 101 }|jrt| �|_qdS )a� 102 Overrides the default whitespace chars 103 104 Example:: 105 106 # default whitespace chars are space, <TAB> and newline 107 Word(alphas)[1, ...].parse_string("abc def\nghi jkl") # -> ['abc', 'def', 'ghi', 'jkl'] 108 109 # change to just treat newline as significant 110 ParserElement.set_default_whitespace_chars(" \t") 111 Word(alphas)[1, ...].parse_string("abc def\nghi jkl") # -> ['abc', 'def'] 112 N)r} r� �_builtin_exprs�copyDefaultWhiteChars�set� 113 whiteChars)r� r� r* r* r+ � set_default_whitespace_chars� s 114 ��z*ParserElement.set_default_whitespace_charsrS c C � 115 | t _dS )al 116 Set class to be used for inclusion of string literals into a parser. 117 118 Example:: 119 120 # default literal class used is Literal 121 integer = Word(nums) 122 date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 123 124 date_str.parse_string("1999/12/31") # -> ['1999', '/', '12', '/', '31'] 125 126 127 # change to Suppress 128 ParserElement.inline_literals_using(Suppress) 129 date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 130 131 date_str.parse_string("1999/12/31") # -> ['1999', '12', '31'] 132 N)r} r� )rS r* r* r+ �inline_literals_using� s 133 z#ParserElement.inline_literals_usingc @ s8 e Zd ZU eje ed< eje ed< eje ed< dS )zParserElement.DebugActions� debug_try� debug_match� 134 debug_failN) r/ r4 r5 �typing�Optional�DebugStartAction�__annotations__�DebugSuccessAction�DebugExceptionActionr* r* r* r+ � DebugActions� s 135 r� �savelistc C s� t � | _d | _d | _d | _d | _|| _d| _tt j 136 �| _ d| _ d| _ d| _t � | _d| _d| _d| _d| _d| _| �d d d �| _d| _d| _g | _d S )NTFrr )�list� parseAction� 137 failAction� 138 customName� _defaultName� resultsName� 139 saveAsList�skipWhitespacer� r} r� r� r� �mayReturnEmpty�keepTabs� ignoreExprs�debug� streamlined� mayIndexError�errmsg� modalResultsr� � debugActions� callPreparse� callDuringTry�suppress_warnings_)r( r� r* r* r+ r, � s* 140 zParserElement.__init__� warning_typec C s | j �|� | S )aY 141 Suppress warnings emitted for a particular diagnostic on this expression. 142 143 Example:: 144 145 base = pp.Forward() 146 base.suppress_warning(Diagnostics.warn_on_parse_using_empty_Forward) 147 148 # statement would normally raise a warning, but is now suppressed 149 print(base.parseString("x")) 150 151 )r� �append)r( r� r* r* r+ �suppress_warning� s z ParserElement.suppress_warningc C s@ t � | �}| jdd� |_| jdd� |_| jr ttj�|_|S )a7 152 Make a copy of this :class:`ParserElement`. Useful for defining 153 different parse actions for the same parsing pattern, using copies of 154 the original parse element. 155 156 Example:: 157 158 integer = Word(nums).set_parse_action(lambda toks: int(toks[0])) 159 integerK = integer.copy().add_parse_action(lambda toks: toks[0] * 1024) + Suppress("K") 160 integerM = integer.copy().add_parse_action(lambda toks: toks[0] * 1024 * 1024) + Suppress("M") 161 162 print((integerK | integerM | integer)[1, ...].parse_string("5K 100 640K 256M")) 163 164 prints:: 165 166 [5120, 100, 655360, 268435456] 167 168 Equivalent form of ``expr.copy()`` is just ``expr()``:: 169 170 integerM = integer().add_parse_action(lambda toks: toks[0] * 1024 * 1024) + Suppress("M") 171 N)�copyr� r� r� r� r} r� r� )r( �cpyr* r* r+ r� � s 172 zParserElement.copy)�listAllMatchesrN �list_all_matchesr� c C s |p|}| � ||�S )a� 173 Define name for referencing matching tokens as a nested attribute 174 of the returned parse results. 175 176 Normally, results names are assigned as you would assign keys in a dict: 177 any existing value is overwritten by later values. If it is necessary to 178 keep all values captured for a particular results name, call ``set_results_name`` 179 with ``list_all_matches`` = True. 180 181 NOTE: ``set_results_name`` returns a *copy* of the original :class:`ParserElement` object; 182 this is so that the client can define a basic element, such as an 183 integer, and reference it in multiple places with different names. 184 185 You can also set results names using the abbreviated syntax, 186 ``expr("name")`` in place of ``expr.set_results_name("name")`` 187 - see :class:`__call__`. If ``list_all_matches`` is required, use 188 ``expr("name*")``. 189 190 Example:: 191 192 date_str = (integer.set_results_name("year") + '/' 193 + integer.set_results_name("month") + '/' 194 + integer.set_results_name("day")) 195 196 # equivalent form: 197 date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 198 )�_setResultsName)r( rN r� r� r* r* r+ �set_results_name s z ParserElement.set_results_namec C s@ |d u r| S | � � }|�d�r|d d� }d}||_| |_|S )Nr r� T)r� �endswithr� r� )r( rN r� �newselfr* r* r+ r� 1 s 199 z ParserElement._setResultsNameT� 200 break_flagc sB |r| j � d� fdd� }� |_|| _ | S t| j d�r | j j| _ | S )z� 201 Method to invoke the Python pdb debugger when this element is 202 about to be parsed. Set ``break_flag`` to ``True`` to enable, ``False`` to 203 disable. 204 Tc s dd l }|�� � | |||�S �Nr )�pdb� set_trace)r� r� � doActions� callPreParser� �� _parseMethodr* r+ �breakerE s z(ParserElement.set_break.<locals>.breaker�_originalParseMethodN�TT)�_parser �hasattr)r( r� r r* r r+ � set_break< s � 205 zParserElement.set_break�fnsc O s\ t |�dgkr g | _| S tdd� |D ��std��dd� |D �| _|�d|�dd ��| _| S ) 206 ao 207 Define one or more actions to perform when successfully matching parse element definition. 208 209 Parse actions can be called to perform data conversions, do extra validation, 210 update external data structures, or enhance or replace the parsed tokens. 211 Each parse action ``fn`` is a callable method with 0-3 arguments, called as 212 ``fn(s, loc, toks)`` , ``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where: 213 214 - s = the original string being parsed (see note below) 215 - loc = the location of the matching substring 216 - toks = a list of the matched tokens, packaged as a :class:`ParseResults` object 217 218 The parsed tokens are passed to the parse action as ParseResults. They can be 219 modified in place using list-style append, extend, and pop operations to update 220 the parsed list elements; and with dictionary-style item set and del operations 221 to add, update, or remove any named results. If the tokens are modified in place, 222 it is not necessary to return them with a return statement. 223 224 Parse actions can also completely replace the given tokens, with another ``ParseResults`` 225 object, or with some entirely different object (common for parse actions that perform data 226 conversions). A convenient way to build a new parse result is to define the values 227 using a dict, and then create the return value using :class:`ParseResults.from_dict`. 228 229 If None is passed as the ``fn`` parse action, all previously added parse actions for this 230 expression are cleared. 231 232 Optional keyword arguments: 233 234 - call_during_try = (default= ``False``) indicate if parse action should be run during 235 lookaheads and alternate testing. For parse actions that have side effects, it is 236 important to only call the parse action once it is determined that it is being 237 called as part of a successful parse. For parse actions that perform additional 238 validation, then call_during_try should be passed as True, so that the validation 239 code is included in the preliminary "try" parses. 240 241 Note: the default parsing behavior is to expand tabs in the input string 242 before starting the parsing process. See :class:`parse_string` for more 243 information on parsing strings containing ``<TAB>`` s, and suggested 244 methods to maintain a consistent view of the parsed string, the parse 245 location, and line and column positions within the parsed string. 246 247 Example:: 248 249 # parse dates in the form YYYY/MM/DD 250 251 # use parse action to convert toks from str to int at parse time 252 def convert_to_int(toks): 253 return int(toks[0]) 254 255 # use a parse action to verify that the date is a valid date 256 def is_valid_date(instring, loc, toks): 257 from datetime import date 258 year, month, day = toks[::2] 259 try: 260 date(year, month, day) 261 except ValueError: 262 raise ParseException(instring, loc, "invalid date given") 263 264 integer = Word(nums) 265 date_str = integer + '/' + integer + '/' + integer 266 267 # add parse actions 268 integer.set_parse_action(convert_to_int) 269 date_str.set_parse_action(is_valid_date) 270 271 # note that integer fields are now ints, not strings 272 date_str.run_tests(''' 273 # successful parse - note that integer fields were converted to ints 274 1999/12/31 275 276 # fail - invalid date 277 1999/13/31 278 ''') 279 Nc s � � | ]}t |�V qd S r& )�callable�r> r� r* r* r+ � <genexpr>� � � z1ParserElement.set_parse_action.<locals>.<genexpr>z parse actions must be callablec S � g | ]}t |��qS r* �r� r r* r* r+ r@ � � z2ParserElement.set_parse_action.<locals>.<listcomp>�call_during_tryr� F)r� r� �allr� �getr� �r( r �kwargsr* r* r+ �set_parse_actionS s K� �z ParserElement.set_parse_actionc O s8 | j dd� |D �7 _ | jp|�d|�dd��| _| S )z� 280 Add one or more parse actions to expression's list of parse actions. See :class:`set_parse_action`. 281 282 See examples in :class:`copy`. 283 c S r r* r r r* r* r+ r@ � r z2ParserElement.add_parse_action.<locals>.<listcomp>r r� F)r� r� r r r* r* r+ �add_parse_action� s 284 285 �z ParserElement.add_parse_actionc 286 O sN |D ]}| j �t||�d�|�dd�d�� q| jp#|�d|�dd��| _| S )a� Add a boolean predicate function to expression's list of parse actions. See 287 :class:`set_parse_action` for function call signatures. Unlike ``set_parse_action``, 288 functions passed to ``add_condition`` need to return boolean success/fail of the condition. 289 290 Optional keyword arguments: 291 292 - message = define a custom message to be used in the raised exception 293 - fatal = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise 294 ParseException 295 - call_during_try = boolean to indicate if this method should be called during internal tryParse calls, 296 default=False 297 298 Example:: 299 300 integer = Word(nums).set_parse_action(lambda toks: int(toks[0])) 301 year_int = integer.copy() 302 year_int.add_condition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later") 303 date_str = year_int + '/' + integer + '/' + integer 304 305 result = date_str.parse_string("1999/12/31") # -> Exception: Only support years 2000 and later (at char 0), 306 (line:1, col:1) 307 r� r� F)r� r� r r� )r� r� r� r r� )r( r r r� r* r* r+ � add_condition� s �� 308 �zParserElement.add_conditionr� c C s 309 || _ | S )a 310 Define action to perform if parsing fails at this expression. 311 Fail acton fn is a callable function that takes the arguments 312 ``fn(s, loc, expr, err)`` where: 313 314 - s = string being parsed 315 - loc = location where expression match was attempted and failed 316 - expr = the parse expression that failed 317 - err = the exception thrown 318 319 The function returns no value. It may throw :class:`ParseFatalException` 320 if it is desired to stop parsing immediately.)r� )r( r� r* r* r+ �set_fail_action� s z ParserElement.set_fail_actionc C sJ d}|r#d}| j D ]}z |�||�\}}d}q ty Y q w |s|S �NTF)r� r r� )r( r� r� � 321 exprsFound�e�dummyr* r* r+ �_skipIgnorables� s 322 � �� z ParserElement._skipIgnorablesc C sZ | j r | �||�}| jr+t|�}| j}||k r+|| |v r+|d7 }||k r+|| |v s |S �Nr )r� r r� �lenr� )r( r� r� �instrlen� white_charsr* r* r+ �preParse� s �zParserElement.preParsec C s |g fS r& r* �r( r� r� r� r* r* r+ � parseImpl � zParserElement.parseImplc C s |S r& r* �r( r� r� � tokenlistr* r* r+ � postParse � zParserElement.postParsec C s& d\}}}| j }t|�} |s| jr�zJ|r | jr | �||�} 323 n|} 324 | 325 } | jjr/| j�|| | d� | js6| 326 | krQz | �|| 327 |�\}} W n t yP t 328 || | j | ��w | �|| 329 |�\}} W na t y� } z| jj rq| j� || | | d� | jr|| �|| | | � � d } ~ ww |r�| jr�| �||�} 330 n|} 331 | 332 } | js�| 333 | kr�z | �|| 334 |�\}} W n t y� t 335 || | j | ��w | �|| 336 |�\}} | �||| �} t| | j| j| jd�}| j�r||s�| j�r||�r;zA| jD ];}z||| |�} W n t y� } zt 337 d�}||�d }~ww | d u�r| |u�rt| | j| j�ot| ttf�| jd�}q�W n^ t �y: } z| jj �r5| j� || | | d� � d } ~ ww | jD ]=}z||| |�} W n t �y\ } zt 338 d�}||�d }~ww | d u�rz| |u�rzt| | j| j�out| ttf�| jd�}�q>|�r�| jj�r�| j�|| || |d� ||fS )N�r r ra F)�asList�modalz exception raised in parse action)r� r! r� r� r$ r� r� r� r& � 339 IndexErrorr� r� � Exceptionr� r* r r� r� r� r� r� � 340 isinstancer� r� )r( r� r� r� r �TRY�MATCH�FAIL� debugging� len_instring�pre_loc� tokens_start�tokens�err� 341 ret_tokensr� �parse_action_excr� r* r* r+ � _parseNoCache s� 342 343 344 �� 345 ��� 346 347 �� 348 �� ��� 349 350 ��� 351 �� �� 352 �zParserElement._parseNoCacher� r� � raise_fatalc C s< z | j ||dd�d W S ty |r� t||| j| ��w )NF�r� r )r r� r� r� )r( r� r� r> r* r* r+ � try_parsen s �zParserElement.try_parsec C s, z | � ||� W dS ttfy Y dS w )NFT)r@ r� r/ )r( r� r� r* r* r+ �can_parse_nextv s ��z ParserElement.can_parse_next�Forward�recursion_memosr c C s� d\}}d\}}} | ||||f} 353 t j�� t j} | �| 354 �} | | ju rdt j| d7 < z 355 | �||||�} W n tyK } z | �| 356 | j | j 357 � � � d } ~ ww | �| 358 | d | d � � |f� | W d � S t j| d7 < | j r�| j jr�z | j j||| dd� W n ty� Y nw t| t�r�| j r�| j jr�z| j j||| | dd� W | � ty� Y | �w | �| d | d � � | d }}}| j r�| j jr�z| j j|||| |dd� W n ty� Y nw ||fW d � S 1 s�w Y d S )N)r r r, r r T)r� ra )r} �packrat_cache_lock� packrat_cacher � not_in_cache�packrat_cache_statsr= �ParseBaseExceptionr� r� r� r� r� r� r� r� r1 r0 r� r� )r( r� r� r� r �HIT�MISSr2 r3 r4 �lookup�cache�value�pe�loc_�resultr� r* r* r+ � _parseCache� s` 359 360 361 �� � � 362 363 � �� 364 � �$�zParserElement._parseCachec C s2 t j�� dgtt j� t jd d �< t j�� d S r� )r} rE �clearr! rG rC r* r* r* r+ � reset_cache� s 365 366 �zParserElement.reset_cachec C s t �� dt _dt _t jt _dS )a$ 367 Disables active Packrat or Left Recursion parsing and their memoization 368 369 This method also works if neither Packrat nor Left Recursion are enabled. 370 This makes it safe to call before activating Packrat nor Left Recursion 371 to clear any previous settings. 372 FN)r} rS �_left_recursion_enabled�_packratEnabledr= r r* r* r* r+ �disable_memoization� s z!ParserElement.disable_memoization)�force�cache_size_limitc C sZ |rt �� nt jrtd��| du rt� t _n| dkr"t| d�t _ntd| ��dt _dS )a# 373 Enables "bounded recursion" parsing, which allows for both direct and indirect 374 left-recursion. During parsing, left-recursive :class:`Forward` elements are 375 repeatedly matched with a fixed recursion depth that is gradually increased 376 until finding the longest match. 377 378 Example:: 379 380 import pyparsing as pp 381 pp.ParserElement.enable_left_recursion() 382 383 E = pp.Forward("E") 384 num = pp.Word(pp.nums) 385 # match `num`, or `num '+' num`, or `num '+' num '+' num`, ... 386 E <<= E + '+' - num | num 387 388 print(E.parse_string("1+2+3")) 389 390 Recursion search naturally memoizes matches of ``Forward`` elements and may 391 thus skip reevaluation of parse actions during backtracking. This may break 392 programs with parse actions which rely on strict ordering of side-effects. 393 394 Parameters: 395 396 - cache_size_limit - (default=``None``) - memoize at most this many 397 ``Forward`` elements during matching; if ``None`` (the default), 398 memoize all ``Forward`` elements. 399 400 Bounded Recursion parsing works similar but not identical to Packrat parsing, 401 thus the two cannot be used together. Use ``force=True`` to disable any 402 previous, conflicting settings. 403 �0Packrat and Bounded Recursion are not compatibleNr )�capacityzMemo size of %sT) r} rV rU � RuntimeError�_UnboundedMemorC �_LRUMemo�NotImplementedErrorrT �rX rW r* r* r+ �enable_left_recursion� s $ 404 405 406 z#ParserElement.enable_left_recursion� rW c C sT |rt �� nt jrtd��t js(dt _| du r t� t _nt| �t _t jt _ dS dS )af 407 Enables "packrat" parsing, which adds memoizing to the parsing logic. 408 Repeated parse attempts at the same string location (which happens 409 often in many complex grammars) can immediately return a cached value, 410 instead of re-executing parsing/validating code. Memoizing is done of 411 both valid results and parsing exceptions. 412 413 Parameters: 414 415 - cache_size_limit - (default= ``128``) - if an integer value is provided 416 will limit the size of the packrat cache; if None is passed, then 417 the cache size will be unbounded; if 0 is passed, the cache will 418 be effectively disabled. 419 420 This speedup may break existing programs that use parse actions that 421 have side-effects. For this reason, packrat parsing is disabled when 422 you first import pyparsing. To activate the packrat feature, your 423 program must call the class method :class:`ParserElement.enable_packrat`. 424 For best results, call ``enable_packrat()`` immediately after 425 importing pyparsing. 426 427 Example:: 428 429 import pyparsing 430 pyparsing.ParserElement.enable_packrat() 431 432 Packrat parsing works similar but not identical to Bounded Recursion parsing, 433 thus the two cannot be used together. Use ``force=True`` to disable any 434 previous, conflicting settings. 435 rY TN) 436 r} rV rT r[ rU r rE r rQ r r_ r* r* r+ �enable_packrat s 437 438 439 �z ParserElement.enable_packrat)�parseAll� parse_allrc c 440 C s� |p|}t �� | js| �� | jD ]}|�� q| js |�� }z"| �|d�\}}|r@| �||�}t � t 441 � }|�||� W |S W |S t yW } z t j rN� |� d��d}~ww )a6 442 Parse a string with respect to the parser definition. This function is intended as the primary interface to the 443 client code. 444 445 :param instring: The input string to be parsed. 446 :param parse_all: If set, the entire input string must match the grammar. 447 :param parseAll: retained for pre-PEP8 compatibility, will be removed in a future release. 448 :raises ParseException: Raised if ``parse_all`` is set and the input string does not match the whole grammar. 449 :returns: the parsed data as a :class:`ParseResults` object, which may be accessed as a `list`, a `dict`, or 450 an object with attributes if the given parser includes results names. 451 452 If the input string is required to match the entire grammar, ``parse_all`` flag must be set to ``True``. This 453 is also equivalent to ending the grammar with :class:`StringEnd`(). 454 455 To report proper column numbers, ``parse_string`` operates on a copy of the input string where all tabs are 456 converted to spaces (8 spaces per tab, as per the default in ``string.expandtabs``). If the input string 457 contains tabs and the grammar uses parse actions that use the ``loc`` argument to index into the string 458 being parsed, one can ensure a consistent view of the input string by doing one of the following: 459 460 - calling ``parse_with_tabs`` on your grammar before calling ``parse_string`` (see :class:`parse_with_tabs`), 461 - define your parse action using the full ``(s,loc,toks)`` signature, and reference the input string using the 462 parse action's ``s`` argument, or 463 - explicitly expand the tabs in your input string before calling ``parse_string``. 464 465 Examples: 466 467 By default, partial matches are OK. 468 469 >>> res = Word('a').parse_string('aaaaabaaa') 470 >>> print(res) 471 ['aaaaa'] 472 473 The parsing behavior varies by the inheriting class of this abstract class. Please refer to the children 474 directly to see more examples. 475 476 It raises an exception if parse_all flag is set and instring does not match the whole grammar. 477 478 >>> res = Word('a').parse_string('aaaaabaaa', parse_all=True) 479 Traceback (most recent call last): 480 ... 481 pyparsing.ParseException: Expected end of text, found 'b' (at char 5), (line:1, col:6) 482 r N)r} rS r� � 483 streamliner� r� � 484 expandtabsr r$ �Empty� StringEndrH r� �with_traceback) r( r� rd rc r r� r9 �ser� r* r* r+ � parse_string4 s. - 485 486 � � 487 ��zParserElement.parse_string)r� � 488 maxMatches� max_matches�overlapr� rl c 489 c sl � t ||�}| js | �� | jD ]}|�� q| js t|��� }t|�}d}| j} | j } 490 t 491 � � d} zn||kr�| |k r�z| ||�} | 492 || dd�\} }W n t yX | d }Y n5w | |kr�| d7 } |rmt |�� | | d�� || | fV |r�| ||�}||kr�| }n |d7 }n| }n| d }||kr�| |k s;W dS W dS W dS W dS ty� } z t 493 jr�� |�d��d}~ww )at 494 Scan the input string for expression matches. Each match will return the 495 matching tokens, start location, and end location. May be called with optional 496 ``max_matches`` argument, to clip scanning after 'n' matches are found. If 497 ``overlap`` is specified, then overlapping matches will be reported. 498 499 Note that the start and end locations are reported relative to the string 500 being parsed. See :class:`parse_string` for more information on parsing 501 strings with embedded tabs. 502 503 Example:: 504 505 source = "sldjf123lsdjjkf345sldkjf879lkjsfd987" 506 print(source) 507 for tokens, start, end in Word(alphas).scan_string(source): 508 print(' '*start + '^'*(end-start)) 509 print(' '*start + tokens[0]) 510 511 prints:: 512 513 sldjf123lsdjjkf345sldkjf879lkjsfd987 514 ^^^^^ 515 sldjf 516 ^^^^^^^ 517 lsdjjkf 518 ^^^^^^ 519 sldkjf 520 ^^^^^^ 521 lkjsfd 522 r F�r r )r9 �start�endN)�minr� re r� r� �strrf r! r$ r r} � 523 resetCacher� r� r- rH r� ri )r( r� rm rn r� rl r r" r� � 524 preparseFn�parseFn�matches�preloc�nextLocr9 �nextlocr� r* r* r+ � scan_stringy s\ � 525 ' 526 527 528 ��� 529 530 (� 531 ��zParserElement.scan_string�r� c 532 C s� g }d}d| _ zX| j||d�D ]3\}}}|�|||� � |r@t|t�r+||�� 7 }nt|t�r;t|t�s;|�|� n|�|� |}q|�||d� � dd� |D �}d� dd� t 533 |�D ��W S t yt } z t j rk� |�d��d}~ww ) ab 534 Extension to :class:`scan_string`, to modify matching text with modified tokens that may 535 be returned from a parse action. To use ``transform_string``, define a grammar and 536 attach a parse action to it that modifies the returned token list. 537 Invoking ``transform_string()`` on a target string will then scan for matches, 538 and replace the matched text patterns according to the logic in the parse 539 action. ``transform_string()`` returns the resulting transformed string. 540 541 Example:: 542 543 wd = Word(alphas) 544 wd.set_parse_action(lambda toks: toks[0].title()) 545 546 print(wd.transform_string("now is the winter of our discontent made glorious summer by this sun of york.")) 547 548 prints:: 549 550 Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York. 551 r Tr| Nc S s g | ]}|r|�qS r* r* �r> �or* r* r+ r@ � r z2ParserElement.transform_string.<locals>.<listcomp>rr c S r r* �rs )r> r� r* r* r+ r@ � r )r� r{ r� r1 r r� r r" �extend�joinr rH r} r� ri ) r( r� r� �out�lastEr� r� r r� r* r* r+ �transform_string� s, 552 553 554 ��z ParserElement.transform_stringc 555 C sV t ||�}ztdd� | j|||d�D ��W S ty* } z tjr!� |�d��d}~ww )a� 556 Another extension to :class:`scan_string`, simplifying the access to the tokens found 557 to match the given parse expression. May be called with optional 558 ``max_matches`` argument, to clip searching after 'n' matches are found. 559 560 Example:: 561 562 # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters 563 cap_word = Word(alphas.upper(), alphas.lower()) 564 565 print(cap_word.search_string("More than Iron, more than Lead, more than Gold I need Electricity")) 566 567 # the sum() builtin can be used to merge results into a single ParseResults object 568 print(sum(cap_word.search_string("More than Iron, more than Lead, more than Gold I need Electricity"))) 569 570 prints:: 571 572 [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']] 573 ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity'] 574 c S s g | ]\}}}|�qS r* r* )r> r� r� r r* r* r+ r@ s z/ParserElement.search_string.<locals>.<listcomp>r| N)rr r r{ rH r} r� ri )r( r� rm r� rl r� r* r* r+ � search_string s 575 � 576 ��zParserElement.search_string)�includeSeparators�maxsplit�include_separatorsc c sZ � |p|}d}| j ||d�D ]\}}}|||� V |r!|d V |}q||d� V dS )aT 577 Generator method to split a string using the given expression as a separator. 578 May be called with optional ``maxsplit`` argument, to limit the number of splits; 579 and the optional ``include_separators`` argument (default= ``False``), if the separating 580 matching text should be included in the split results. 581 582 Example:: 583 584 punc = one_of(list(".,;:/-!?")) 585 print(list(punc.split("This, this?, this sentence, is badly punctuated!"))) 586 587 prints:: 588 589 ['This', ' this', '', ' this sentence', ' is badly punctuated', ''] 590 r )rm N)r{ ) r( r� r� r� r� �lastr� r� r r* r* r+ rG ( s � 591 zParserElement.splitc C sN |t u rt| �S t|t�r| �|�}t|t�s!td�t|�j ���t 592 | |g�S )ah 593 Implementation of ``+`` operator - returns :class:`And`. Adding strings to a :class:`ParserElement` 594 converts them to :class:`Literal`s by default. 595 596 Example:: 597 598 greet = Word(alphas) + "," + Word(alphas) + "!" 599 hello = "Hello, World!" 600 print(hello, "->", greet.parse_string(hello)) 601 602 prints:: 603 604 Hello, World! -> ['Hello', ',', 'World', '!'] 605 606 ``...`` may be used as a parse expression as a short form of :class:`SkipTo`. 607 608 Literal('start') + ... + Literal('end') 609 610 is equivalent to: 611 612 Literal('start') + SkipTo('end')("_skipped*") + Literal('end') 613 614 Note that the skipped text is returned with '_skipped' as a results name, 615 and to support having multiple skips in the same parser, the value returned is 616 a list of all skipped text. 617 �4Cannot combine element of type {} with ParserElement) �Ellipsis� _PendingSkipr1 r" r� r} r� r� r� r/ �And�r( �otherr* r* r+ �__add__H s 618 619 620 �� zParserElement.__add__c C sR |t u r t| �d�| S t|t�r| �|�}t|t�s%td�t|�j ���|| S )zd 621 Implementation of ``+`` operator when left operand is not a :class:`ParserElement` 622 � _skipped*r� ) 623 r� �SkipTor1 r" r� r} r� r� r� r/ r� r* r* r+ �__radd__p s 624 625 626 ��zParserElement.__radd__c C sB t |t�r 627 | �|�}t |t�std�t|�j���| t� � | S )zX 628 Implementation of ``-`` operator, returns :class:`And` with error stop 629 r� ) 630 r1 r" r� r} r� r� r� r/ r� � 631 _ErrorStopr� r* r* r+ �__sub__� s 632 633 634 ��zParserElement.__sub__c C s: t |t�r 635 | �|�}t |t�std�t|�j���|| S )zd 636 Implementation of ``-`` operator when left operand is not a :class:`ParserElement` 637 r� �r1 r" r� r} r� r� r� r/ r� r* r* r+ �__rsub__� � 638 639 640 ��zParserElement.__rsub__c s |t u rd}n t|t�r#|dd� t fkr#d|dd� d dd� }t|t�r.|d}}n}t|t�r�tdd � |D ��}|d 641 dd� }|d du rPd|d f}t|d t�r{|d du r{|d dkrgt��S |d dkrqt��S �|d t�� S t|d t�r�t|d t�r�|\}}||8 }ntd �d �d d � |D �����td�t |�j 642 ���|dk r�t d��|dk r�t d��|| kr�dkr�t g �S |r� �fdd�� |r�|dkr��� |� }|S t �g| �� |� }|S � |�}|S |dkr��}|S t �g| �}|S )a� 643 Implementation of ``*`` operator, allows use of ``expr * 3`` in place of 644 ``expr + expr + expr``. Expressions may also be multiplied by a 2-integer 645 tuple, similar to ``{min, max}`` multipliers in regular expressions. Tuples 646 may also include ``None`` as in: 647 - ``expr*(n, None)`` or ``expr*(n, )`` is equivalent 648 to ``expr*n + ZeroOrMore(expr)`` 649 (read as "at least n instances of ``expr``") 650 - ``expr*(None, n)`` is equivalent to ``expr*(0, n)`` 651 (read as "0 to n instances of ``expr``") 652 - ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)`` 653 - ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)`` 654 655 Note that ``expr*(None, n)`` does not raise an exception if 656 more than n exprs exist in the input stream; that is, 657 ``expr*(None, n)`` does not enforce a maximum number of expr 658 occurrences. If this behavior is desired, then write 659 ``expr*(None, n) + ~expr`` 660 )r NNr r� r& ra r c s s � | ] }|t ur 661 |nd V qd S r& )r� r} r* r* r+ r � s � z(ParserElement.__mul__.<locals>.<genexpr>)NNz.cannot multiply ParserElement and ({}) objects�,c s s � | ]}t |�jV qd S r& �r� r/ )r> �itemr* r* r+ r � � � z,cannot multiply ParserElement and {} objectsz/cannot multiply ParserElement by negative valuez@second tuple value must be greater or equal to first tuple valuec s$ | dkrt �� | d � �S t ��S r )�Opt)�n��makeOptionalListr( r* r+ r� � s z/ParserElement.__mul__.<locals>.makeOptionalList) r� r1 �tuple�int� 662 ZeroOrMore� OneOrMorer� r� r� r� r/ � 663 ValueErrorr� )r( r� � minElements� optElementsr2 r* r� r+ �__mul__� sl 664 665 666 ������ 667 ����zParserElement.__mul__c C s 668 | � |�S r& )r� r� r* r* r+ �__rmul__� r- zParserElement.__rmul__c C sR |t u r 669 t| dd�S t|t�r| �|�}t|t�s#td�t|�j ���t 670 | |g�S )zP 671 Implementation of ``|`` operator - returns :class:`MatchFirst` 672 T)� must_skipr� ) r� r� r1 r" r� r} r� r� r� r/ � 673 MatchFirstr� r* r* r+ �__or__� s 674 675 676 �� zParserElement.__or__c C s: t |t�r 677 | �|�}t |t�std�t|�j���|| B S )zd 678 Implementation of ``|`` operator when left operand is not a :class:`ParserElement` 679 r� r� r� r* r* r+ �__ror__ r� zParserElement.__ror__c C �> t |t�r 680 | �|�}t |t�std�t|�j���t| |g�S )zH 681 Implementation of ``^`` operator - returns :class:`Or` 682 r� ) r1 r" r� r} r� r� r� r/ �Orr� r* r* r+ �__xor__ � 683 684 685 �� zParserElement.__xor__c C s: t |t�r 686 | �|�}t |t�std�t|�j���|| A S )zd 687 Implementation of ``^`` operator when left operand is not a :class:`ParserElement` 688 r� r� r� r* r* r+ �__rxor__# r� zParserElement.__rxor__c C r� )zJ 689 Implementation of ``&`` operator - returns :class:`Each` 690 r� ) r1 r" r� r} r� r� r� r/ �Eachr� r* r* r+ �__and__1 r� zParserElement.__and__c C s: t |t�r 691 | �|�}t |t�std�t|�j���|| @ S )zd 692 Implementation of ``&`` operator when left operand is not a :class:`ParserElement` 693 r� r� r� r* r* r+ �__rand__? r� zParserElement.__rand__c C � t | �S )zL 694 Implementation of ``~`` operator - returns :class:`NotAny` 695 )�NotAny�r( r* r* r+ � 696 __invert__M s zParserElement.__invert__c C s� zt |t�r |f}t|� W n ty ||f}Y nw t|�dkr=td�|dd� t|�dkr9d�t|�����d���| t|dd� � }|S )a{ 697 use ``[]`` indexing notation as a short form for expression repetition: 698 699 - ``expr[n]`` is equivalent to ``expr*n`` 700 - ``expr[m, n]`` is equivalent to ``expr*(m, n)`` 701 - ``expr[n, ...]`` or ``expr[n,]`` is equivalent 702 to ``expr*n + ZeroOrMore(expr)`` 703 (read as "at least n instances of ``expr``") 704 - ``expr[..., n]`` is equivalent to ``expr*(0, n)`` 705 (read as "0 to n instances of ``expr``") 706 - ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)`` 707 - ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)`` 708 709 ``None`` may be used in place of ``...``. 710 711 Note that ``expr[..., n]`` and ``expr[m, n]``do not raise an exception 712 if more than ``n`` ``expr``s exist in the input stream. If this behavior is 713 desired, then write ``expr[..., n] + ~expr``. 714 ra z,only 1 or 2 index arguments supported ({}{})Nrc z... [{}]rr )r1 r" �iterr� r! r� r� )r( �keyr2 r* r* r+ � __getitem__W s$ 715 � "����zParserElement.__getitem__c C s |dur | � |�S | �� S )a 716 Shortcut for :class:`set_results_name`, with ``list_all_matches=False``. 717 718 If ``name`` is given with a trailing ``'*'`` character, then ``list_all_matches`` will be 719 passed as ``True``. 720 721 If ``name` is omitted, same as calling :class:`copy`. 722 723 Example:: 724 725 # these are equivalent 726 userdata = Word(alphas).set_results_name("name") + Word(nums + "-").set_results_name("socsecno") 727 userdata = Word(alphas)("name") + Word(nums + "-")("socsecno") 728 N)r� r� �r( rN r* r* r+ �__call__ s 729 zParserElement.__call__c C r� )z� 730 Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from 731 cluttering up returned output. 732 )�Suppressr� r* r* r+ �suppress� s zParserElement.suppress� recursivec C � 733 d| _ | S )z� 734 Enables the skipping of whitespace before matching the characters in the 735 :class:`ParserElement`'s defined pattern. 736 737 :param recursive: If ``True`` (the default), also enable whitespace skipping in child elements (if any) 738 T�r� �r( r� r* r* r+ �ignore_whitespace� s z ParserElement.ignore_whitespacec C r� )a| 739 Disables the skipping of whitespace before matching the characters in the 740 :class:`ParserElement`'s defined pattern. This is normally only used internally by 741 the pyparsing module, but may be needed in some whitespace-sensitive grammars. 742 743 :param recursive: If true (the default), also disable whitespace skipping in child elements (if any) 744 Fr� r� r* r* r+ �leave_whitespace� s z ParserElement.leave_whitespace� copy_defaultsc C s d| _ t|�| _|| _| S )z8 745 Overrides the default whitespace chars 746 T)r� r� r� r� )r( r� r� r* r* r+ �set_whitespace_chars� s 747 z"ParserElement.set_whitespace_charsc C r� )z� 748 Overrides default behavior to expand ``<TAB>`` s to spaces before parsing the input string. 749 Must be called before ``parse_string`` when the input grammar contains elements that 750 match ``<TAB>`` characters. 751 T)r� r� r* r* r+ �parse_with_tabs� s z ParserElement.parse_with_tabsr� c C sV ddl }t|t�r t|�}t|t�r || jvr | j�|� | S | j�t|�� �� | S )a� 752 Define expression to be ignored (e.g., comments) while doing pattern 753 matching; may be called repeatedly, to define multiple comment or other 754 ignorable patterns. 755 756 Example:: 757 758 patt = Word(alphas)[1, ...] 759 patt.parse_string('ablaj /* comment */ lskjd') 760 # -> ['ablaj'] 761 762 patt.ignore(c_style_comment) 763 patt.parse_string('ablaj /* comment */ lskjd') 764 # -> ['ablaj', 'lskjd'] 765 r N)r� r1 r" r� r� r� r� )r( r� r� r* r* r+ �ignore� s 766 767 768 �zParserElement.ignore� start_action�success_action�exception_actionc C s& | � |pt|pt|p t�| _d| _| S )a 769 Customize display of debugging messages while doing pattern matching: 770 771 - ``start_action`` - method to be called when an expression is about to be parsed; 772 should have the signature ``fn(input_string: str, location: int, expression: ParserElement, cache_hit: bool)`` 773 774 - ``success_action`` - method to be called when an expression has successfully parsed; 775 should have the signature ``fn(input_string: str, start_location: int, end_location: int, expression: ParserELement, parsed_tokens: ParseResults, cache_hit: bool)`` 776 777 - ``exception_action`` - method to be called when expression fails to parse; 778 should have the signature ``fn(input_string: str, location: int, expression: ParserElement, exception: Exception, cache_hit: bool)`` 779 T)r� r� r� r� r� r� )r( r� r� r� r* r* r+ �set_debug_actions� s �z ParserElement.set_debug_actions�flagc C s |r | � ttt� | S d| _| S )a� 780 Enable display of debugging messages while doing pattern matching. 781 Set ``flag`` to ``True`` to enable, ``False`` to disable. 782 783 Example:: 784 785 wd = Word(alphas).set_name("alphaword") 786 integer = Word(nums).set_name("numword") 787 term = wd | integer 788 789 # turn on debugging for wd 790 wd.set_debug() 791 792 term[1, ...].parse_string("abc 123 xyz 890") 793 794 prints:: 795 796 Match alphaword at loc 0(1,1) 797 Matched alphaword -> ['abc'] 798 Match alphaword at loc 3(1,4) 799 Exception raised:Expected alphaword (at char 4), (line:1, col:5) 800 Match alphaword at loc 7(1,8) 801 Matched alphaword -> ['xyz'] 802 Match alphaword at loc 11(1,12) 803 Exception raised:Expected alphaword (at char 12), (line:1, col:13) 804 Match alphaword at loc 15(1,16) 805 Exception raised:Expected alphaword (at char 15), (line:1, col:16) 806 807 The output shown is that produced by the default debug actions - custom debug actions can be 808 specified using :class:`set_debug_actions`. Prior to attempting 809 to match the ``wd`` expression, the debugging message ``"Match <exprname> at loc <n>(<line>,<col>)"`` 810 is shown. Then if the parse succeeds, a ``"Matched"`` message is shown, or an ``"Exception raised"`` 811 message is shown. Also note the use of :class:`set_name` to assign a human-readable name to the expression, 812 which makes debugging and exception messages easier to understand - for instance, the default 813 name created for the :class:`Word` expression without calling ``set_name`` is ``"W:(A-Za-z)"``. 814 F)r� r� r� r� r� )r( r� r* r* r+ � set_debug� s %��zParserElement.set_debugc C s | j d u r 815 | �� | _ | j S r& )r� �_generateDefaultNamer� r* r* r+ � default_name( s 816 817 zParserElement.default_namec C r� )zg 818 Child classes must define this method, which defines how the ``default_name`` is set. 819 Nr* r� r* r* r+ r� . r� z"ParserElement._generateDefaultNamec C s$ || _ d| j | _tjr| �� | S )a\ 820 Define name for this expression, makes debugging and exception messages clearer. 821 Example:: 822 Word(nums).parse_string("ABC") # -> Exception: Expected W:(0-9) (at char 0), (line:1, col:1) 823 Word(nums).set_name("integer").parse_string("ABC") # -> Exception: Expected integer (at char 0), (line:1, col:1) 824 � Expected )r� rN r� rI r] r� r� r* r* r+ �set_name4 s 825 zParserElement.set_namec C s | j d ur| j S | jS r& )r� r� r� r* r* r+ rN A s zParserElement.namec C � | j S r& �rN r� r* r* r+ �__str__F � zParserElement.__str__c C r� r& r r� r* r* r+ �__repr__I r' zParserElement.__repr__c C s d| _ d | _| S �NT)r� r� r� r* r* r+ re L s zParserElement.streamlinec C � g S r& r* r� r* r* r+ �recurseQ r+ zParserElement.recursec C s. |d d � | g }| � � D ]}|�|� q d S r& )r� �_checkRecursion�r( �parseElementList�subRecCheckListr r* r* r+ r� T s �z ParserElement._checkRecursionc C s | � g � dS )zj 826 Check defined expressions for valid structure, check for infinite recursive definitions. 827 N)r� )r( � validateTracer* r* r+ �validateY s zParserElement.validate�utf-8�file_or_filename�encodingc C s� |p|}z|� � }W n$ ty. t|d|d�� }|� � }W d � n1 s'w Y Y nw z| �||�W S tyK } z tjrB� |�d��d}~ww )z� 828 Execute the parse expression on the given file or filename. 829 If a filename is specified (instead of a file object), 830 the entire file is opened, read, and closed before parsing. 831 �r�r� N)�read�AttributeError�openrk rH r} r� ri )r( r� r� rd rc � file_contents�fr� r* r* r+ � 832 parse_file_ s" 833 ��� 834 ��zParserElement.parse_filec C sB | |u rdS t |t�r| j|dd�S t |t�r t| �t|�kS dS )NT�rd F)r1 r" rw r} �varsr� r* r* r+ �__eq__{ s 835 836 zParserElement.__eq__c C r� r& )�idr� r* r* r+ �__hash__� r' zParserElement.__hash__� test_stringc C s6 |o|}z | j t|�|d� W dS ty Y dS w )a� 837 Method for quick testing of a parser against a test string. Good for simple 838 inline microtests of sub expressions while building up larger parser. 839 840 Parameters: 841 - ``test_string`` - to test against this expression for a match 842 - ``parse_all`` - (default= ``True``) - flag to pass to :class:`parse_string` when running tests 843 844 Example:: 845 846 expr = Word(nums) 847 assert expr.matches("100") 848 r� TF)rk rs rH )r( r� rd rc r* r* r+ rw � s �zParserElement.matches�#)rc �fullDump� printResults� failureTestsr* �tests�comment� full_dump� print_results� failure_tests� 849 post_parse�file�with_line_numbersr� r� r� r* c 850 s( ddl m} | 851 o |} 852 | o |} | o|} | p|} |p|}t|t�r1t|�j� � fdd�|�� �� D �}t|t�r:t|�}|du rAt j 853 }|j }g }g }d}td�� t d���t�}d }|D �]4}|durg|�|d 854 �sk|rx|sx|�| rt|�|�n|� qZ|s{qZ|r�dd�|� nd | r�|�|�n|g}g }z|�|�|��}| j|| 855 d �}W nn ty� } z1t|t�r�d nd }|�|�� � |�dt|� � tj r�|� t � |j �� |o�| }|}W Y d}~n�d}~w t!�y } z%|�d�"t|�j#|�� tj r�|� t � |j �� |�o| }|}W Y d}~nmd}~ww |�o| }|du�rpz)|||�} | du�r=t| t$��r5|�| �%� � n|�t| �� n|�|�%� � W n3 t!�yo } z |�|j%| d�� |�d�"|j#t| �j#| �� W Y d} ~ nd} ~ ww |�|j%| d�� |�d � | �r�|d�|�� |�||f� qZ||fS )a� 856 Execute the parse expression on a series of test strings, showing each 857 test, the parsed results or where the parse failed. Quick and easy way to 858 run a parse expression against a list of sample strings. 859 860 Parameters: 861 - ``tests`` - a list of separate test strings, or a multiline string of test strings 862 - ``parse_all`` - (default= ``True``) - flag to pass to :class:`parse_string` when running tests 863 - ``comment`` - (default= ``'#'``) - expression for indicating embedded comments in the test 864 string; pass None to disable comment filtering 865 - ``full_dump`` - (default= ``True``) - dump results as list followed by results names in nested outline; 866 if False, only dump nested list 867 - ``print_results`` - (default= ``True``) prints test output to stdout 868 - ``failure_tests`` - (default= ``False``) indicates if these tests are expected to fail parsing 869 - ``post_parse`` - (default= ``None``) optional callback for successful parse results; called as 870 `fn(test_string, parse_results)` and returns a string to be added to the test output 871 - ``file`` - (default= ``None``) optional file-like object to which test output will be written; 872 if None, will default to ``sys.stdout`` 873 - ``with_line_numbers`` - default= ``False``) show test strings with line and column numbers 874 875 Returns: a (success, results) tuple, where success indicates that all tests succeeded 876 (or failed if ``failure_tests`` is True), and the results contain a list of lines of each 877 test's output 878 879 Example:: 880 881 number_expr = pyparsing_common.number.copy() 882 883 result = number_expr.run_tests(''' 884 # unsigned integer 885 100 886 # negative integer 887 -100 888 # float with scientific notation 889 6.02e23 890 # integer with scientific notation 891 1e-12 892 ''') 893 print("Success" if result[0] else "Failed!") 894 895 result = number_expr.run_tests(''' 896 # stray character 897 100Z 898 # missing leading digit before '.' 899 -.100 900 # too many '.' 901 3.14.159 902 ''', failure_tests=True) 903 print("Success" if result[0] else "Failed!") 904 905 prints:: 906 907 # unsigned integer 908 100 909 [100] 910 911 # negative integer 912 -100 913 [-100] 914 915 # float with scientific notation 916 6.02e23 917 [6.02e+23] 918 919 # integer with scientific notation 920 1e-12 921 [1e-12] 922 923 Success 924 925 # stray character 926 100Z 927 ^ 928 FAIL: Expected end of text (at char 3), (line:1, col:4) 929 930 # missing leading digit before '.' 931 -.100 932 ^ 933 FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1) 934 935 # too many '.' 936 3.14.159 937 ^ 938 FAIL: Expected end of text (at char 4), (line:1, col:5) 939 940 Success 941 942 Each test string must be on a single line. If you want to test a string that spans multiple 943 lines, create a test like this:: 944 945 expr.run_tests(r"this is a test\n of strings that spans \n 3 lines") 946 947 (Note that this is a raw string literal, you must include the leading ``'r'``.) 948 r )�pyparsing_testc s g | ]}� |��qS r* r* )r> � test_line�� 949 line_stripr* r+ r@ r z+ParserElement.run_tests.<locals>.<listcomp>NT�\n� 950 u Frr r� z(FATAL)zFAIL: zFAIL-EXCEPTION: {}: {})�fullz{} failed: {}: {})&�testingr r1 r" r� �strip�rstrip� 951 splitlines�Literal�sys�stdout�writer � replace_withr� � quoted_stringrw r� r� r� r� �lstriprk rH r� �explainrs r} r� r� r� � format_tbr� r0 r� r/ r �dump) r( r� rd r� r� r� r� r� r� r� rc r� r� r� r* r �print_� 952 allResults�comments�success�NL�BOMr� r� rP rN r� r� �pp_valuer r* r r+ � run_tests� s� p 953 954 955 956 ��� 957 �� 958 959 960 ����� 961 zParserElement.run_testsr# � output_html�vertical�show_results_names� show_groupsc 962 K s� z 963 ddl m}m} W n ty } ztd�|�d}~ww | �� || ||||d�} t|ttf�rQt |ddd��} 964 | 965 � 966 || �� W d � dS 1 sJw Y dS |� 967 || �� dS ) a� 968 Create a railroad diagram for the parser. 969 970 Parameters: 971 - output_html (str or file-like object) - output target for generated 972 diagram HTML 973 - vertical (int) - threshold for formatting multiple alternatives vertically 974 instead of horizontally (default=3) 975 - show_results_names - bool flag whether diagram should show annotations for 976 defined results names 977 - show_groups - bool flag whether groups should be highlighted with an unlabeled surrounding box 978 Additional diagram-formatting keyword arguments can also be included; 979 see railroad.Diagram class. 980 r )� to_railroad�railroad_to_htmlzMmust ``pip install pyparsing[diagrams]`` to generate parser railroad diagramsN)r r r �diagram_kwargs�wr� r� ) �diagramr! r" � ImportErrorr0 re r1 rs r r� r ) r( r r r r r r! r" �ie�railroad� diag_filer* r* r+ �create_diagrama s. �����"�z ParserElement.create_diagram�F�rP r} �Tr rU r& )ra )r� r} rP r} )r� F)Tr� TTFNNF)r# FF)�r/ r4 r5 rB r� rs r� r� rs r� r� r� r� � staticmethodr� r� r r� r, r` r� r� r� r� r � ParseActionr r �ParseConditionr �ParseFailActionr r r$ r& r* r r� r r= r@ rA r �recursion_lockrC �Dictr r0 rE rD rG rQ r rS rU rT rV r` rb rk �_MAX_INTr r{ r� r� rG r� r� r� r� r� r� r� r� r� r� r� r� r� �__iter__r� r� r� r� r� r 981 r� r� r� r� r� r� r� r� �propertyr� r r� r� rN r� r� re r r� r� r� r r r� r� r� rw r r r r* �setDefaultWhitespaceChars�inlineLiteralsUsing�setResultsName�setBreak�setParseAction�addParseAction� addCondition� setFailAction�tryParse� canParseNextrt �enableLeftRecursion� enablePackrat� parseString� 982 scanString� searchString�transformString�setWhitespaceChars� parseWithTabs�setDebugActions�setDebug� defaultName�setName� parseFile�runTests�ignoreWhitespace�leaveWhitespacer* r* r* r+ r} � sV 983 984 ����� 985 � 986 ! V # 987 � 988 989 � f � ��� 990 991 �0 ��� �/ ,����� 992 �H������� 993 � Y1������ 994 �+����� 995 � 996 997 ( 998 999 1000 1001 V 1002 1003 1004 1005 1006 1007 1008 ( 1009 1010 ��� 1011 � 1012 1013 ��� 1014 �/ 1015 1016 �� ���� 1017 � ����� 1018 �� �������� � 1019 � � ���� 1020 � G� ���� 1021 �.c sJ e Zd Zddedef� fdd� Zdd� Zdd 1022 d �Zd d � Zdd� Z � Z 1023 S )r� Fr� r� c s t � �� || _|| _d S r& )�superr, �anchorr� )r( r� r� �r� r* r+ r, � � 1024 1025 z_PendingSkip.__init__c C s t | jt� ��dd�S )Nrg �...)rs rR rg �replacer� r* r* r+ r� � � z!_PendingSkip._generateDefaultNamerP r} c s\ t |��d�d�}� jr'dd� }� fdd�}� j|� �|� |� �|�B | S � j| | S )NrU r� c S s0 | j r | j �� dgkr| d= | �dd � d S d S )Nrr r �_skipped)rX r� �pop�r� r* r* r+ r� � s �z'_PendingSkip.__add__.<locals>.must_skipc s@ | j �� dd � dgkr | �d� dt� j� d | d< d S d S )Nr� rr rX z missing <�>)rX r� rY �reprrR rZ r� r* r+ � show_skip� s 1026 �z'_PendingSkip.__add__.<locals>.show_skip)r� r� r� rR r )r( r� �skipperr� r] r* r� r+ r� � s 1027 ��z_PendingSkip.__add__c C r� r& )rK r� r* r* r+ r� � r� z_PendingSkip.__repr__c G s t d��)NzBuse of `...` expression without following SkipTo target expression)r0 )r( r� r* r* r+ r& � s �z_PendingSkip.parseImplr+ r, ) r/ r4 r5 r} rs r, r� r� r� r& � __classcell__r* r* rS r+ r� � s 1028 r� c s( e Zd ZdZ� fdd�Zdd� Z� ZS )�TokenzYAbstract :class:`ParserElement` subclass, for defining atomic 1029 matching patterns. 1030 c s t � jdd� d S )NF�r� �rQ r, r� rS r* r+ r, � � zToken.__init__c C s 1031 t | �jS r& r� r� r* r* r+ r� � r- zToken._generateDefaultName)r/ r4 r5 rB r, r� r_ r* r* rS r+ r` � s r` c s e Zd ZdZ� fdd�Z� ZS )rg z, 1032 An empty token, will always match. 1033 c � t � �� d| _d| _d S r �rQ r, r� r� r� rS r* r+ r, � rT zEmpty.__init__)r/ r4 r5 rB r, r_ r* r* rS r+ rg � s rg c �* e Zd ZdZ� fdd�Zddd�Z� ZS )�NoMatchz( 1034 A token that will never match. 1035 c s t � �� d| _d| _d| _d S )NTFzUnmatchable token)rQ r, r� r� r� r� rS r* r+ r, � s 1036 1037 zNoMatch.__init__Tc C s t ||| j| ��r& )r� r� r% r* r* r+ r& � s zNoMatch.parseImplr- �r/ r4 r5 rB r, r& r_ r* r* rS r+ rg � � rg c sD e Zd ZdZd dd�dedef� fdd�Zdd � Zdd d �Z� ZS )r a� 1038 Token to exactly match a specified string. 1039 1040 Example:: 1041 1042 Literal('blah').parse_string('blah') # -> ['blah'] 1043 Literal('blah').parse_string('blahfooblah') # -> ['blah'] 1044 Literal('blah').parse_string('bla') # -> Exception: Expected "blah" 1045 1046 For case-insensitive matching, use :class:`CaselessLiteral`. 1047 1048 For keyword matching (force word break before and after the matched string), 1049 use :class:`Keyword` or :class:`CaselessKeyword`. 1050 rr �� matchString� match_stringrk c s� t � �� |p|}|| _t|�| _z|d | _W n ty# td��w d| j | _ d| _ 1051 d| _ | jdkr@t | �t u rBt| _d S d S d S )Nr z2null string passed to Literal; use Empty() insteadr� Fr )rQ r, �matchr! �matchLen�firstMatchCharr/ r� rN r� r� r� r� r �_SingleCharLiteralr� �r( rl rk rS r* r+ r, s 1052 1053 � 1054 �zLiteral.__init__c C � 1055 t | j�S r& �r\ rm r� r* r* r+ r� r- z Literal._generateDefaultNameTc C s< || | j kr|�| j|�r|| j | jfS t||| j| ��r& )ro r< rm rn r� r� r% r* r* r+ r& s 1056 �zLiteral.parseImpl�rr r- ) r/ r4 r5 rB rs r, r� r& r_ r* r* rS r+ r � s 1057 r c @ � e Zd Zddd�ZdS )rp Tc C s, || | j kr|d | jfS t||| j| ��r )ro rm r� r� r% r* r* r+ r& ) s z _SingleCharLiteral.parseImplNr- �r/ r4 r5 r& r* r* r* r+ rp ( � rp c s~ e Zd ZdZed Z dddd�dedeje d e d 1058 ed eje f 1059 � fd d �Z 1060 dd� Z ddd�Z e ddd��ZeZ� ZS )�Keyworda� 1061 Token to exactly match a specified string as a keyword, that is, 1062 it must be immediately followed by a non-keyword character. Compare 1063 with :class:`Literal`: 1064 1065 - ``Literal("if")`` will match the leading ``'if'`` in 1066 ``'ifAndOnlyIf'``. 1067 - ``Keyword("if")`` will not; it will only match the leading 1068 ``'if'`` in ``'if x=1'``, or ``'if(y==2)'`` 1069 1070 Accepts two optional constructor arguments in addition to the 1071 keyword string: 1072 1073 - ``identChars`` is a string of characters that would be valid 1074 identifier characters, defaulting to all alphanumerics + "_" and 1075 "$" 1076 - ``caseless`` allows case-insensitive matching, default is ``False``. 1077 1078 Example:: 1079 1080 Keyword("start").parse_string("start") # -> ['start'] 1081 Keyword("start").parse_string("starting") # -> Exception 1082 1083 For case-insensitive matching, use :class:`CaselessKeyword`. 1084 z_$rr NF�rk � 1085 identCharsrl � ident_chars�caselessrk rz c s� t � �� |p|}|d u rtj}|p|}|| _t|�| _z|d | _W n ty. t d��w d� 1086 t | �j | j �| _d| _d| _|| _|rN|�� | _|�� }t|�| _d S )Nr z2null string passed to Keyword; use Empty() insteadzExpected {} {}F)rQ r, rx �DEFAULT_KEYWORD_CHARSrm r! rn ro r/ r� r� r� r/ rN r� r� r� r| �upper� caselessmatchr� rz )r( rl r{ r| rk rz rS r* r+ r, O s( 1087 1088 � 1089 zKeyword.__init__c C rr r& rs r� r* r* r+ r� l r- z Keyword._generateDefaultNameTc C sR | j }|}| jrU|||| j � �� | jkrT|dks%||d �� | jvrL|t|�| j ks:||| j �� | jvrB|| j | jfS |d7 }|| j }nV|d7 }|d }nM|| | jkra| jdksh|� | j|�r�|dksu||d | jvr�|t|�| j ks�||| j | jvr�|| j | jfS |d7 }|| j }n|d7 }|d }t 1090 |||| ��)Nr r z/, was immediately followed by keyword characterz7, keyword was immediately preceded by keyword characterz7, keyword was immediately followed by keyword character) r� r| rn r~ r rz r! rm ro r< r� )r( r� r� r� r� �errlocr* r* r+ r& o s8 � 1091 �� zKeyword.parseImplrP c C r� )zX 1092 Overrides the default characters used by :class:`Keyword` expressions. 1093 N)rx r} )r� r* r* r+ �set_default_keyword_chars� s 1094 z!Keyword.set_default_keyword_chars)rr NFr- rU )r/ r4 r5 rB � alphanumsr} rs r� r� rs r, r� r& r. r� �setDefaultKeywordCharsr_ r* r* rS r+ rx 2 s2 ������� 1095 / rx c s< e Zd ZdZd dd�dedef� fdd�Zd d d 1096 �Z� ZS ) �CaselessLiteralaq 1097 Token to match a specified string, ignoring case of letters. 1098 Note: the matched results will always be in the case of the given 1099 match string, NOT the case of the input text. 1100 1101 Example:: 1102 1103 CaselessLiteral("CMD")[1, ...].parse_string("cmd CMD Cmd10") 1104 # -> ['CMD', 'CMD', 'CMD'] 1105 1106 (Contrast with example for :class:`CaselessKeyword`.) 1107 rr rj rl rk c s. |p|}t � �|�� � || _d| j | _d S )Nr� )rQ r, r~ � returnStringrN r� rq rS r* r+ r, � s zCaselessLiteral.__init__Tc C s< |||| j � �� | jkr|| j | jfS t||| j| ��r& )rn r~ rm r� r� r� r% r* r* r+ r& � s zCaselessLiteral.parseImplrt r- )r/ r4 r5 rB rs r, r& r_ r* r* rS r+ r� � s r� c sL e Zd ZdZ d ddd�dedeje dedeje f� fd d 1108 �Z� ZS ) �CaselessKeywordz� 1109 Caseless version of :class:`Keyword`. 1110 1111 Example:: 1112 1113 CaselessKeyword("CMD")[1, ...].parse_string("cmd CMD Cmd10") 1114 # -> ['CMD', 'CMD'] 1115 1116 (Contrast with example for :class:`CaselessLiteral`.) 1117 rr Nry rl r{ rk rz c s& |p|}|p|}t � j||dd� d S )NT)r| rb )r( rl r{ rk rz rS r* r+ r, � s zCaselessKeyword.__init__)rr N) r/ r4 r5 rB rs r� r� r, r_ r* r* rS r+ r� � s ������r� c sL e Zd ZdZ dddd�dededef� fd d 1118 �Zd d � Zddd�Z� Z S )� 1119 CloseMatcha� A variation on :class:`Literal` which matches "close" matches, 1120 that is, strings with at most 'n' mismatching characters. 1121 :class:`CloseMatch` takes parameters: 1122 1123 - ``match_string`` - string to be matched 1124 - ``caseless`` - a boolean indicating whether to ignore casing when comparing characters 1125 - ``max_mismatches`` - (``default=1``) maximum number of 1126 mismatches allowed to count as a match 1127 1128 The results from a successful parse will contain the matched text 1129 from the input string and the following named results: 1130 1131 - ``mismatches`` - a list of the positions within the 1132 match_string where mismatches were found 1133 - ``original`` - the original match_string used to compare 1134 against the input string 1135 1136 If ``mismatches`` is an empty list, then the match was an exact 1137 match. 1138 1139 Example:: 1140 1141 patt = CloseMatch("ATCATCGAATGGA") 1142 patt.parse_string("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']}) 1143 patt.parse_string("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1) 1144 1145 # exact match 1146 patt.parse_string("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']}) 1147 1148 # close match allowing up to 2 mismatches 1149 patt = CloseMatch("ATCATCGAATGGA", max_mismatches=2) 1150 patt.parse_string("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']}) 1151 Nr F)� maxMismatchesr| rl �max_mismatchesr� c sN |d ur|n|}t � �� || _|| _d�| j| j�| _|| _d| _d| _d S )Nz(Expected {!r} (with up to {} mismatches)F) rQ r, rl r� r� r� r| r� r� )r( rl r� r� r| rS r* r+ r, � s 1152 � 1153 zCloseMatch.__init__c C s d� t| �j| j�S )Nz{}:{!r})r� r� r/ rl r� r* r* r+ r� 1154 � z CloseMatch._generateDefaultNameTc C s� |}t |�}|t | j� }||krg| j}d}g } | j} 1155 tt|||� |��D ]%\}} | \} } | jr:| �� | �� } } | | krK| �|� t | �| 1156 krK n q&|| d }t|||� g�}||d< | |d< ||fS t ||| j 1157 | ��)Nr r �original� 1158 mismatches) r! rl r� � enumerate�zipr| rt r� r r� r� )r( r� r� r� rp r" �maxlocrl �match_stringlocr� r� �s_m�src�mat�resultsr* r* r+ r& 1159 s2 � 1160 � zCloseMatch.parseImplr& r- � 1161 r/ r4 r5 rB rs r� r, r� r& r_ r* r* rS r+ r� � s %�����r� c s� e Zd ZdZ dddddd�ded eje d 1162 ed ed ed edeje deje deje dedeje f� fdd�Z dd� Z 1163 ddd�Z � Z S ) �Worda8 Token for matching words composed of allowed character sets. 1164 Parameters: 1165 - ``init_chars`` - string of all characters that should be used to 1166 match as a word; "ABC" will match "AAA", "ABAB", "CBAC", etc.; 1167 if ``body_chars`` is also specified, then this is the string of 1168 initial characters 1169 - ``body_chars`` - string of characters that 1170 can be used for matching after a matched initial character as 1171 given in ``init_chars``; if omitted, same as the initial characters 1172 (default=``None``) 1173 - ``min`` - minimum number of characters to match (default=1) 1174 - ``max`` - maximum number of characters to match (default=0) 1175 - ``exact`` - exact number of characters to match (default=0) 1176 - ``as_keyword`` - match as a keyword (default=``False``) 1177 - ``exclude_chars`` - characters that might be 1178 found in the input ``body_chars`` string but which should not be 1179 accepted for matching ;useful to define a word of all 1180 printables except for one or two characters, for instance 1181 (default=``None``) 1182 1183 :class:`srange` is useful for defining custom character set strings 1184 for defining :class:`Word` expressions, using range notation from 1185 regular expression character sets. 1186 1187 A common mistake is to use :class:`Word` to match a specific literal 1188 string, as in ``Word("Address")``. Remember that :class:`Word` 1189 uses the string argument to define *sets* of matchable characters. 1190 This expression would match "Add", "AAA", "dAred", or any other word 1191 made up of the characters 'A', 'd', 'r', 'e', and 's'. To match an 1192 exact literal string, use :class:`Literal` or :class:`Keyword`. 1193 1194 pyparsing includes helper strings for building Words: 1195 1196 - :class:`alphas` 1197 - :class:`nums` 1198 - :class:`alphanums` 1199 - :class:`hexnums` 1200 - :class:`alphas8bit` (alphabetic characters in ASCII range 128-255 1201 - accented, tilded, umlauted, etc.) 1202 - :class:`punc8bit` (non-alphabetic characters in ASCII range 1203 128-255 - currency, symbols, superscripts, diacriticals, etc.) 1204 - :class:`printables` (any non-whitespace character) 1205 1206 ``alphas``, ``nums``, and ``printables`` are also defined in several 1207 Unicode sets - see :class:`pyparsing_unicode``. 1208 1209 Example:: 1210 1211 # a word composed of digits 1212 integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9")) 1213 1214 # a word with a leading capital, and zero or more lowercase 1215 capital_word = Word(alphas.upper(), alphas.lower()) 1216 1217 # hostnames are alphanumeric, with leading alpha, and '-' 1218 hostname = Word(alphas, alphanums + '-') 1219 1220 # roman numeral (not a strict parser, accepts invalid mix of characters) 1221 roman = Word("IVXLCDM") 1222 1223 # any string of non-whitespace characters, except for ',' 1224 csv_value = Word(printables, exclude_chars=",") 1225 rr Nr r F)� initChars� bodyChars� asKeyword� excludeChars� 1226 init_chars� 1227 body_charsrr �max�exact� 1228 as_keyword� exclude_charsr� r� r� r� c s� |p|}| p|} | 1229 p |} 1230 | p|} t � �� |s!td�t| �j���t|�}|| _| r:t| �} || 8 }| r:t| �| } d�t |��| _ 1231 | rRd�t | ��| _ t| �| _ n d�t |��| _ t|�| _ |dk| _ |dk rltd��|| _|dkrw|| _nt| _|dkr�|| _|| _d| j | _d| _| 1232 | _d| j| j B v�rI|dk�rK|dk�rM| j | jkr�|dkr�d } n|dkr�d} nd 1233 �| j| jtkr�dn| j�} d �t| j�| �| _nIt| j�dkr�|dkr�d } nd �|d �} d�t�| j 1234 �t| j �| �| _n$|dkr�d } n|dk�rd} nd �|d �} d�t| j�t| j �| �| _| j�r&d| j d | _z t�| j�| _W n tj�y> d | _Y d S w | jj | _ t | _ d S d S d S d S )Nz,invalid {}, initChars cannot be empty stringrr r r zUcannot specify a minimum length < 1; use Opt(Word()) if zero-length word is permittedr� Fr� �+� {{{},{}}}z[{}]{}r z{{0,{}}}z{}[{}]{}ra z 1235 [{}][{}]{}z\b) rQ r, r� r� r� r/ r� r� r� �sorted� initCharsOrig� bodyCharsOrigr� � maxSpecified�minLen�maxLenr4 rN r� r� r� r �reStringr! �re�escape�compile�errorrm �re_match� 1236 _WordRegexr� ) r( r� r� rr r� r� r� r� r� r� r� r� �repeatrS r* r+ r, v 1237 s� 1238 �� 1239 1240 � & �� 1241 � 1242 � � 1243 1244 �z Word.__init__c C s� dd� }| j | jkrd�|| j �|| j��}nd�|| j ��}| jdks)| jtkrY| j| jkrB| jdkr:|dd � S |d�| j� S | jtkrO|d�| j� S |d �| j| j� S |S ) 1245 Nc S s4 d}t | dd�} t| �|kr| d |d � d S | S )N� F)� re_escaper# rU )r r! )r� � max_repr_lenr* r* r+ � 1246 charsAsStr� 1247 s 1248 z-Word._generateDefaultName.<locals>.charsAsStrz 1249 W:({}, {})zW:({})r ra z{{{}}}z 1250 {{{},...}}r� )r� r� r� r� r� r4 )r( r� �baser* r* r+ r� � 1251 s � 1252 1253 zWord._generateDefaultNameTc C s || | j vrt||| j| ��|}|d7 }t|�}| j}|| j }t||�}||k r>|| |v r>|d7 }||k r>|| |v s0d}|| | jk rJd}n+| jrZ||k rZ|| |v rZd}n| j ru|dkri||d |v ss||k ru|| |v rud}|rt||| j| ��||||� fS )Nr FTr ) 1254 r� r� r� r! r� r� rr r� r� r� ) r( r� r� r� rp r" � bodycharsr� �throwExceptionr* r* r+ r& s2 1255 1256 � zWord.parseImpl)rr Nr r r FNr- ) r/ r4 r5 rB rs r� r� r� rs r, r� r& r_ r* r* rS r+ r� 5 1257 sN B� 1258 �������� 1259 � � � �q r� c @ ru )r� Tc C s4 | � ||�}|st||| j| ��|�� }||�� fS r& )r� r� r� rq �group)r( r� r� r� rP r* r* r+ r& & s 1260 z_WordRegex.parseImplNr- rv r* r* r* r+ r� % rw r� c sP e Zd ZdZ d ddd�dededeje ded eje f 1261 � fd 1262 d �Z� Z S ) �Charz�A short-cut class for defining :class:`Word` ``(characters, exact=1)``, 1263 when defining a match of any single character in a string of 1264 characters. 1265 FN)r� r� �charsetr� r� r� r� c sd |p|}|p|}t � j|d||d� d�t| j��| _|r$d�| j�| _t�| j�| _| jj| _ d S )Nr )r� r� r� z[{}]z\b{}\b) 1266 rQ r, r� r r� r� r� r� rm r� )r( r� r� r� r� r� rS r* r+ r, 5 s �z Char.__init__)FN) 1267 r/ r4 r5 rB rs rs r� r� r, r_ r* r* rS r+ r� / s$ �������r� c s� e Zd ZdZ d ddd�dedeejef de de d e d 1268 e f � fd d �Z 1269 e d d� �Ze dd� �Z e dd� �Z dd� Zd!dd�Zd!dd�Zd!dd�Zd ed efd d �Z� ZS )"�Regexa� Token for matching strings that match a given regular 1270 expression. Defined with string specifying the regular expression in 1271 a form recognized by the stdlib Python `re module <https://docs.python.org/3/library/re.html>`_. 1272 If the given regex contains named groups (defined using ``(?P<name>...)``), 1273 these will be preserved as named :class:`ParseResults`. 1274 1275 If instead of the Python stdlib ``re`` module you wish to use a different RE module 1276 (such as the ``regex`` module), you can do so by building your ``Regex`` object with 1277 a compiled RE that was compiled using ``regex``. 1278 1279 Example:: 1280 1281 realnum = Regex(r"[+-]?\d+\.\d*") 1282 # ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression 1283 roman = Regex(r"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})") 1284 1285 # named fields in a regex will be returned as named results 1286 date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)') 1287 1288 # the Regex class will accept re's compiled using the regex module 1289 import regex 1290 parser = pp.Regex(regex.compile(r'[0-9]')) 1291 r F)� asGroupList�asMatch�pattern�flags� as_group_list�as_matchr� r� c s� t � �� |p|}|p |}t|t�r%|std��d| _| | _| _|| _n t |d�r=t |d�r=|| _|j | _| _|| _nt 1292 d��d| j | _ d| _ || _|| _| jrW| j| _| jr`| j| _dS dS )a The parameters ``pattern`` and ``flags`` are passed 1293 to the ``re.compile()`` function as-is. See the Python 1294 `re module <https://docs.python.org/3/library/re.html>`_ module for an 1295 explanation of the acceptable patterns and flags. 1296 z0null string passed to Regex; use Empty() insteadNr� rm zCRegex may only be constructed with a string or a compiled RE objectr� F)rQ r, r1 r" r� �_rer� r� r� r r� rN r� r� r� r� �parseImplAsGroupListr& �parseImplAsMatch)r( r� r� r� r� r� r� rS r* r+ r, c s2 1297 1298 � �zRegex.__init__c C s@ | j r| j S z t�| j| j�W S tjy td�| j���w )Nz&invalid pattern ({!r}) passed to Regex)r� r� r� r� r� r� r� r� r� r* r* r+ r� � s 1299 ��zRegex.rec C s | j jS r& )r� rm r� r* r* r+ r� � s zRegex.re_matchc C s | � d�d uS �Nrr )r� r� r* r* r+ r� � s zRegex.mayReturnEmptyc C s d� t| j��dd��S )NzRe:({})z\\�\)r� r\ r� rV r� r* r* r+ r� � rW zRegex._generateDefaultNameTc C sb | � ||�}|st||| j| ��|�� }t|�� �}|�� }|r-|�� D ]\}}|||< q$||fS r& )r� r� r� rq r r� � groupdict�items) r( r� r� r� rP r2 �d�k�vr* r* r+ r& � s 1300 zRegex.parseImplc C s8 | � ||�}|st||| j| ��|�� }|�� }||fS r& )r� r� r� rq �groups�r( r� r� r� rP r2 r* r* r+ r� � s zRegex.parseImplAsGroupListc C s4 | � ||�}|st||| j| ��|�� }|}||fS r& )r� r� r� rq r� r* r* r+ r� � s zRegex.parseImplAsMatch�replrP c sP �j rtd���jrt� �rtd���jr � fdd�}n� �fdd�}��|�S )a� 1301 Return :class:`Regex` with an attached parse action to transform the parsed 1302 result as if called using `re.sub(expr, repl, string) <https://docs.python.org/3/library/re.html#re.sub>`_. 1303 1304 Example:: 1305 1306 make_html = Regex(r"(\w+):(.*?):").sub(r"<\1>\2</\1>") 1307 print(make_html.transform_string("h1:main title:")) 1308 # prints "<h1>main title</h1>" 1309 z-cannot use sub() with Regex(asGroupList=True)z9cannot use sub() with a callable with Regex(asMatch=True)c s | d � � �S r� )�expand�r9 )r� r* r+ r� � � zRegex.sub.<locals>.pac s �j �� | d �S r� )r� �subr� �r� r( r* r+ r� � rc )r� r� r� r r )r( r� r� r* r� r+ r� � s 1310 z Regex.sub)r FFr- )r/ r4 r5 rB r r r� � RegexFlagr� rs r, r% r� r� r� r& r� r� rs r} r� r_ r* r* rS r+ r� J s@ ��� �����. 1311 1312 1313 1314 1315 1316 r� c s� e Zd ZdZdZ dddddddd�ded eje d 1317 eje d ed ed eje dededeje deje dedeje def� fdd�Z dd� Z 1318 d dd�Z � Z S ) � QuotedStringa 1319 Token for matching strings that are delimited by quoting characters. 1320 1321 Defined with the following parameters: 1322 1323 - ``quote_char`` - string of one or more characters defining the 1324 quote delimiting string 1325 - ``esc_char`` - character to re_escape quotes, typically backslash 1326 (default= ``None``) 1327 - ``esc_quote`` - special quote sequence to re_escape an embedded quote 1328 string (such as SQL's ``""`` to re_escape an embedded ``"``) 1329 (default= ``None``) 1330 - ``multiline`` - boolean indicating whether quotes can span 1331 multiple lines (default= ``False``) 1332 - ``unquote_results`` - boolean indicating whether the matched text 1333 should be unquoted (default= ``True``) 1334 - ``end_quote_char`` - string of one or more characters defining the 1335 end of the quote delimited string (default= ``None`` => same as 1336 quote_char) 1337 - ``convert_whitespace_escapes`` - convert escaped whitespace 1338 (``'\t'``, ``'\n'``, etc.) to actual whitespace 1339 (default= ``True``) 1340 1341 Example:: 1342 1343 qs = QuotedString('"') 1344 print(qs.search_string('lsjdf "This is the quote" sldjf')) 1345 complex_qs = QuotedString('{{', end_quote_char='}}') 1346 print(complex_qs.search_string('lsjdf {{This is the "quote"}} sldjf')) 1347 sql_qs = QuotedString('"', esc_quote='""') 1348 print(sql_qs.search_string('lsjdf "This is the quote with ""embedded"" quotes" sldjf')) 1349 1350 prints:: 1351 1352 [['This is the quote']] 1353 [['This is the "quote"']] 1354 [['This is the quote with "embedded" quotes']] 1355 ))z\t� )r r )z\f� )z\r� rr NFT)� quoteChar�escChar�escQuote�unquoteResults� endQuoteChar�convertWhitespaceEscapes� 1356 quote_char�esc_char� esc_quote� multiline�unquote_results�end_quote_char�convert_whitespace_escapesr� r� r� r� r� r� c sV t � �� | p|} | 1357 p |} 1358 | o|} | p|} | o|} |p |}|�� }|s'td��| d u r.|} n 1359 | �� } | s8td��|� _t|�� _|d � _| � _t| �� _ | � _ 1360 | 1361 � _ | � _ | � _ d}d}| 1362 rl|d�|t�| 1363 ��7 }d}| r�|d�|t�| ��7 }d}t�� j 1364 �d � _t� j�d kr�|d 1365 �|�d�� fd d �tt� j�d dd �D �� d 7 }d}|r�tjtjB � _|d�|t� jd �| d ur�t| �nd�7 }nd� _|d�|t� jd �| d ur�t| �nd�7 }d�t�� j�d|dt�� j�g�� _zt�� j� j�� _� j� _� jj� _ W n tj �y td�� j���w d� j � _ d� _ d� _!d S )Nz%quote_char cannot be the empty stringz'endQuoteChar cannot be the empty stringr rr z{}(?:{})�|z {}(?:{}.)z(.)r z{}(?:c 3 s< � | ]}d � t�� jd|� �t�� j|d� ��V qdS )z (?:{}(?!{}))N)r� r� r� r� )r> rp r� r* r+ r N s � �� 1366 �z(QuotedString.__init__.<locals>.<genexpr>r� �)z {}(?:[^{}{}])z{}(?:[^{}\n\r{}])z(?:z)*z$invalid pattern {!r} passed to Regexr� FT)"rQ r, r r� r� r! � quoteCharLen�firstQuoteCharr� �endQuoteCharLenr� r� r� r� r� r� r� �escCharReplacePatternr� �range� MULTILINE�DOTALLr� r r� r� r� rm r� r� rN r� r� r� )r( r� r� r� r� r� r� r� r� r� r� r� r� r� �sep� inner_patternrS r� r+ r, s� 1367 � 1368 1369 1370 ���� � � 1371 1372 �� 1373 1374 �� 1375 zQuotedString.__init__c C s4 | j | jkrt| j t�rd�| j �S d�| j | j�S )Nzstring enclosed in {!r}z.quoted string, starting with {} ending with {})r� r� r1 r" r� r� r* r* r+ r� s 1376 �z!QuotedString._generateDefaultNamec C s� || | j kr | �||�pd }|st||| j| ��|�� }|�� }| jr]|| j| j � }t |t 1377 �r]d|v rG| j rG| j D ] 1378 \}}|� ||�}q<| jrRt�| jd|�}| jr]|� | j| j�}||fS )Nr� z\g<1>)r� r� r� r� rq r� r� r� r� r1 r" r� �ws_maprV r� r� r� r� r� r� )r( r� r� r� rP r2 �wslit�wscharr* r* r+ r& � s( 1379 �� 1380 zQuotedString.parseImpl)rr NNFTNTr- ) r/ r4 r5 rB r� rs r� r� rs r, r� r& r_ r* r* rS r+ r� � s\ &� 1381 �������� 1382 � � � ���qr� c sX e Zd ZdZ ddd�dededed ed 1383 ef 1384 � fd d �Zd d� Zddd�Z� Z S )� 1385 CharsNotIna� Token for matching words composed of characters *not* in a given 1386 set (will include whitespace in matched characters if not listed in 1387 the provided exclusion set - see example). Defined with string 1388 containing all disallowed characters, and an optional minimum, 1389 maximum, and/or exact length. The default value for ``min`` is 1390 1 (a minimum value < 1 is not valid); the default values for 1391 ``max`` and ``exact`` are 0, meaning no maximum or exact 1392 length restriction. 1393 1394 Example:: 1395 1396 # define a comma-separated-value as anything that is not a ',' 1397 csv_value = CharsNotIn(',') 1398 print(delimited_list(csv_value).parse_string("dkls,lsdkjf,s12 34,@!#,213")) 1399 1400 prints:: 1401 1402 ['dkls', 'lsdkjf', 's12 34', '@!#', '213'] 1403 rr r r )�notChars� not_charsrr r� r� r� c s� t � �� d| _|p || _t| j�| _|dk rtd��|| _|dkr&|| _nt | _|dkr3|| _|| _d| j 1404 | _ | jdk| _ d| _ d S )NFr zacannot specify a minimum length < 1; use Opt(CharsNotIn()) if zero-length char group is permittedr r� )rQ r, r� r� r� � notCharsSetr� r� r� r4 rN r� r� r� )r( r� rr r� r� r� rS r* r+ r, � s$ 1405 1406 � 1407 zCharsNotIn.__init__c C s6 t | j�}t|�dkrd�| jd d� �S d�| j�S )Nr� z 1408 !W:({}...)� z!W:({}))r r� r! r� )r( � not_chars_strr* r* r+ r� � s 1409 z CharsNotIn._generateDefaultNameTc C s� | j }|| |v rt||| j| ��|}|d7 }t|| j t|��}||k r9|| |vr9|d7 }||k r9|| |vs+|| | jk rHt||| j| ��||||� fS r )r� r� r� rr r� r! r� )r( r� r� r� �notcharsrp �maxlenr* r* r+ r& � s �zCharsNotIn.parseImpl)rr r r r r- r� r* r* rS r+ r� � s* �������#r� c s� e Zd ZdZi dd�dd�dd�dd �d 1410 d �d d �dd�dd�dd�dd�dd�dd�dd�d d �d d �d d!�d"d#�d$d%d&d'd(d)d*��Zd9d.ed/ed0ed1ef� fd2d3� Zd4d5� Zd:d7d8�Z � Z 1411 S );�Whitea� Special matching class for matching whitespace. Normally, 1412 whitespace is ignored by pyparsing grammars. This class is included 1413 when some whitespace structures are significant. Define with 1414 a string containing the whitespace characters to be matched; default 1415 is ``" \t\r\n"``. Also takes optional ``min``, 1416 ``max``, and ``exact`` arguments, as defined for the 1417 :class:`Word` class. 1418 r� z<SP>r� z<TAB>r z<LF>r� z<CR>r� z<FF>� z<NBSP>u z<OGHAM_SPACE_MARK>u z<MONGOLIAN_VOWEL_SEPARATOR>u z <EN_QUAD>u z <EM_QUAD>u z 1419 <EN_SPACE>u z 1420 <EM_SPACE>u z<THREE-PER-EM_SPACE>u z<FOUR-PER-EM_SPACE>u z<SIX-PER-EM_SPACE>u z<FIGURE_SPACE>u z<PUNCTUATION_SPACE>z <THIN_SPACE>z <HAIR_SPACE>z<ZERO_WIDTH_SPACE>z<NNBSP>z<MMSP>z<IDEOGRAPHIC_SPACE>)u u u u u u � 1421 r r �wsrr r� r� c s~ t � �� |� _� jd�� fdd�� jD ��dd� d� _d� j � _|� _ |dkr.|� _ 1422 nt � _ 1423 |dkr=|� _ 1424 |� _ d S d S )Nrr c 3 s � | ] 1425 }|� j vr|V qd S r& )� 1426 matchWhiter� r� r* r+ r ! s � z!White.__init__.<locals>.<genexpr>T�r� r� r ) rQ r, r r� r� � whiteStrsr� rN r� r� r� r4 )r( r� rr r� r� rS r� r+ r, s 1427 � 1428 �zWhite.__init__c C s d� dd� | jD ��S )Nrr c s s � | ]}t j| V qd S r& )r� r r� r* r* r+ r 4 r� z-White._generateDefaultName.<locals>.<genexpr>)r� r r� r* r* r+ r� 3 � zWhite._generateDefaultNameTc C s� || | j vrt||| j| ��|}|d7 }|| j }t|t|��}||k r;|| | j v r;|d7 }||k r;|| | j v s,|| | jk rJt||| j| ��||||� fS r )r r� r� r� rr r! r� )r( r� r� r� rp r� r* r* r+ r& 6 s 1429 �zWhite.parseImpl)r� r r r r- ) r/ r4 r5 rB r rs r� r, r� r& r_ r* r* rS r+ r� � s^ �������� � 1430 � � � ������ r� c s e Zd Z� fdd�Z� ZS )� PositionTokenc rd r re r� rS r* r+ r, G rT zPositionToken.__init__)r/ r4 r5 r, r_ r* r* rS r+ r F s r c s8 e Zd ZdZdef� fdd� Zdd� Zd 1431 dd �Z� ZS ) � 1432 GoToColumnzaToken to advance to a specific column of input text; useful for 1433 tabular report scraping. 1434 �colnoc s t � �� || _d S r& )rQ r, r� )r( r rS r* r+ r, R � 1435 1436 zGoToColumn.__init__c C s~ t ||�| j kr=t|�}| jr| �||�}||k r=|| �� r=t ||�| j kr=|d7 }||k r=|| �� r=t ||�| j ks'|S r )r� r! r� r �isspace)r( r� r� r" r* r* r+ r$ V s 1437 �� 1438 �zGoToColumn.preParseTc C sD t ||�}|| j krt||d| ��|| j | }|||� }||fS )NzText not in expected column)r� r� )r( r� r� r� �thiscol�newlocr2 r* r* r+ r& c s 1439 1440 zGoToColumn.parseImplr- ) r/ r4 r5 rB r� r, r$ r& r_ r* r* rS r+ r M s 1441 r c s2 e Zd ZdZ� fdd�Zdd� Zd dd�Z� ZS ) 1442 � LineStarta� Matches if current position is at the beginning of a line within 1443 the parse string 1444 1445 Example:: 1446 1447 test = '''\ 1448 AAA this line 1449 AAA and this line 1450 AAA but not this one 1451 B AAA and definitely not this one 1452 ''' 1453 1454 for t in (LineStart() + 'AAA' + restOfLine).search_string(test): 1455 print(t) 1456 1457 prints:: 1458 1459 ['AAA', ' this line'] 1460 ['AAA', ' and this line'] 1461 1462 c sF t � �� | �� t� | jB | _| j�d� t� �| j�| _ d| _ 1463 d S )Nr zExpected start of line) rQ r, r� r� r� �orig_whiteChars�discardrg r� r^ r� r� rS r* r+ r, � s 1464 1465 zLineStart.__init__c C sb |dkr|S | j �||�}d| jv r/|||d � dkr/| j �||d �}|||d � dks |S )Nr r r )r^ r$ r )r( r� r� r2 r* r* r+ r$ � s 1466 �zLineStart.preParseTc C s& t ||�dkr |g fS t||| j| ��r )r� r� r� r% r* r* r+ r& � s zLineStart.parseImplr- )r/ r4 r5 rB r, r$ r& r_ r* r* rS r+ r l s 1467 1468 r c rf )�LineEndzTMatches if current position is at the end of a line within the 1469 parse string 1470 c s0 t � �� | j�d� | j| jdd� d| _d S )Nr Fr zExpected end of line)rQ r, r� r r� r� r� rS r* r+ r, � s 1471 1472 zLineEnd.__init__Tc C s\ |t |�k r|| dkr|d dfS t||| j| ��|t |�kr&|d g fS t||| j| ��)Nr r �r! r� r� r% r* r* r+ r& � s zLineEnd.parseImplr- rh r* r* rS r+ r � ri r c rf )� StringStartzLMatches if current position is at the beginning of the parse 1473 string 1474 c � t � �� d| _d S )NzExpected start of text�rQ r, r� r� rS r* r+ r, � r zStringStart.__init__Tc C s0 |dkr|| � |d�krt||| j| ��|g fS r� )r$ r� r� r% r* r* r+ r& � s zStringStart.parseImplr- rh r* r* rS r+ r � � r c rf )rh zG 1475 Matches if current position is at the end of the parse string 1476 c r )NzExpected end of textr r� rS r* r+ r, � r zStringEnd.__init__Tc C sX |t |�k rt||| j| ��|t |�kr|d g fS |t |�kr$|g fS t||| j| ��r r r% r* r* r+ r& � s zStringEnd.parseImplr- rh r* r* rS r+ rh � r rh c �> e Zd ZdZefed�dedef� fdd�Zd 1477 dd �Z� ZS ) � WordStarta� Matches if the current position is at the beginning of a 1478 :class:`Word`, and is not preceded by any character in a given 1479 set of ``word_chars`` (default= ``printables``). To emulate the 1480 ```` behavior of regular expressions, use 1481 ``WordStart(alphanums)``. ``WordStart`` will also match at 1482 the beginning of the string being parsed, or at the beginning of 1483 a line. 1484 �� wordChars� 1485 word_charsr c s. |t kr|n|}t� �� t|�| _d| _d S )NzNot at the start of a word)� 1486 printablesrQ r, r� r r� �r( r r rS r* r+ r, � s 1487 1488 1489 zWordStart.__init__Tc C s@ |dkr ||d | j v s|| | j vr t||| j| ��|g fS �Nr r )r r� r� r% r* r* r+ r& � s 1490 zWordStart.parseImplr- � r/ r4 r5 rB r rs r, r& r_ r* r* rS r+ r � s r c r ) �WordEndai Matches if the current position is at the end of a :class:`Word`, 1491 and is not followed by any character in a given set of ``word_chars`` 1492 (default= ``printables``). To emulate the ```` behavior of 1493 regular expressions, use ``WordEnd(alphanums)``. ``WordEnd`` 1494 will also match at the end of the string being parsed, or at the end 1495 of a line. 1496 r r r c s4 |t kr|n|}t� �� t|�| _d| _d| _d S )NFzNot at the end of a word)r rQ r, r� r r� r� r rS r* r+ r, � s 1497 1498 1499 1500 zWordEnd.__init__Tc C sP t |�}|dkr$||k r$|| | jv s ||d | jvr$t||| j| ��|g fS r )r! r r� r� )r( r� r� r� r" r* r* r+ r& s zWordEnd.parseImplr- r r* r* rS r+ r � s r c s� e Zd ZdZd deje def� fdd� Zde e fdd �Z 1501 defd 1502 d �Z d d edef� fdd� Z d d edef� fdd� Z def� fdd� Zdd� Zdef� fdd� Zd!d"dd�Zdef� fdd � Zd � fd d � Ze Ze Z� ZS )#�ParseExpressionz]Abstract subclass of ParserElement, for combining and 1503 post-processing parsed tokens. 1504 F�exprsr� c s� t � �|� � t|t�rt|�}t|t�r � �|�g� _n@t|t�r(|g� _n6t|t �rIt|�}t 1505 dd� |D ��rC� fdd�|D �}t|�� _nzt|�� _W n t y] |g� _Y nw d� _ d S )Nc s s � | ]}t |t�V qd S r& )r1 r" )r> r� r* r* r+ r r� z+ParseExpression.__init__.<locals>.<genexpr>c 3 s( � | ]}t |t�r� �|�n|V qd S r& )r1 r" r� �r> r r� r* r+ r s 1506 � � 1507 �F) rQ r, r1 �_generatorTyper� r" r� r r} r �anyr� r� �r( r r� rS r� r+ r, s* 1508 1509 1510 1511 1512 1513 � � 1514 zParseExpression.__init__rP c C s | j d d � S r& )r r� r* r* r+ r� + r� zParseExpression.recursec C s | j �|� d | _| S r& )r r� r� r� r* r* r+ r� . s zParseExpression.appendTr� c �< t � �|� |r dd� | jD �| _| jD ]}|�|� q| S )z� 1515 Extends ``leave_whitespace`` defined in base class, and also invokes ``leave_whitespace`` on 1516 all contained expressions. 1517 c S � g | ]}|� � �qS r* �r� r r* r* r+ r@ ; r z4ParseExpression.leave_whitespace.<locals>.<listcomp>)rQ r� r �r( r� r rS r* r+ r� 3 s 1518 z ParseExpression.leave_whitespacec r$ )z� 1519 Extends ``ignore_whitespace`` defined in base class, and also invokes ``leave_whitespace`` on 1520 all contained expressions. 1521 c S r% r* r& r r* r* r+ r@ G r z5ParseExpression.ignore_whitespace.<locals>.<listcomp>)rQ r� r r' rS r* r+ r� @ s 1522 z!ParseExpression.ignore_whitespacec sl t |t�r || jvr t� �|� | jD ] 1523 }|�| jd � q| S t� �|� | jD ] 1524 }|�| jd � q)| S �Nr� )r1 r� r� rQ r� r )r( r� r rS r* r+ r� L � 1525 1526 1527 � 1528 zParseExpression.ignorec C � d� | jjt| j��S �Nz{}:({}))r� r� r/ rs r r� r* r* r+ r� X r z$ParseExpression._generateDefaultNamec s& | j r| S t� �� | jD ]}|�� q t| j�dkr�| jd }t|| j�rR|jsR|jd u rR|j sR|jd d � | jd g | _d | _ 1529 | j |j O _ | j |j O _ | jd }t|| j�r�|js�|jd u r�|j s�| jd d� |jd d � | _d | _ 1530 | j |j O _ | j |j O _ dt | � | _| S )Nra r r r� r� )r� rQ re r r! r1 r� r� r� r� r� r� r� rs r� )r( r r� rS r* r+ re [ s@ 1531 1532 1533 1534 1535 �� 1536 � 1537 1538 �� 1539 � zParseExpression.streamlineNc C sB |d ur|ng d d � | g }| j D ]}|�|� q| �g � d S r& )r r� r� )r( r� �tmpr r* r* r+ r� � s 1540 zParseExpression.validatec s t � �� }dd� | jD �|_|S )Nc S r% r* r& r r* r* r+ r@ � r z(ParseExpression.copy.<locals>.<listcomp>)rQ r� r �r( r2 rS r* r+ r� � s 1541 zParseExpression.copyc sj t jr.tj| jvr.| jD ]!}t|t�r-|jr-tj|jvr-tj d� 1542 d|t | �j |j�dd� q t � �||�S �NzY{}: setting results name {!r} on {} expression collides with {!r} on contained expressionrW r# �� 1543 stacklevel)rI rW r` r� r r1 r} r� �warningsrL r� r� r/ rQ r� �r( rN r� r rS r* r+ r� � s2 �� 1544 ������ z ParseExpression._setResultsNamer+ r- r& rU )r/ r4 r5 rB r� r r} rs r, r r� r� r� r� r� r� re r� r� r� rO rP r_ r* r* rS r+ r s ) r c sx e Zd ZdZG dd� de�Z ddeje de f� fdd� Z 1545 d ef� fd 1546 d � Z dd d �Z dd� Z dd� Zdd� Z� ZS )r� a 1547 Requires all given :class:`ParseExpression` s to be found in the given order. 1548 Expressions may be separated by whitespace. 1549 May be constructed using the ``'+'`` operator. 1550 May also be constructed using the ``'-'`` operator, which will 1551 suppress backtracking. 1552 1553 Example:: 1554 1555 integer = Word(nums) 1556 name_expr = Word(alphas)[1, ...] 1557 1558 expr = And([integer("id"), name_expr("name"), integer("age")]) 1559 # more easily written as: 1560 expr = integer("id") + name_expr("name") + integer("age") 1561 c s$ e Zd Z� fdd�Zdd� Z� ZS )zAnd._ErrorStopc s t � j|i |�� | �� d S r& )rQ r, r� )r( r� r rS r* r+ r, � s zAnd._ErrorStop.__init__c C r� )N�-r* r� r* r* r+ r� � r+ z#And._ErrorStop._generateDefaultName)r/ r4 r5 r, r� r_ r* r* rS r+ r� � s r� T� exprs_argr� c s t |�}|rFt|v rFg }t|�D ]/\}}|tu r:|t|�d k r6t� ||d jd }|�t|�d�� qtd��|�|� q||d d �< t � � 1562 ||� | jr~t dd� | jD ��| _ t | jd t�sz| j| jd j| jd jd� | jd j| _nd | _nd 1563 | _ d 1564 | _d S ) Nr r� r� z0cannot construct And with sequence ending in ...c s � � | ]}|j V qd S r& �r� r r* r* r+ r � � � z And.__init__.<locals>.<genexpr>r r FT)r� r� r� r! rg r r� r� r0 rQ r, r r� r1 r� r� r� r� r� r� )r( r4 r� r r, rp r� � 1565 skipto_argrS r* r+ r, � s2 � 1566 1567 � 1568 z And.__init__rP c sH | j rStdd� | j d d� D ��rSt| j d d� �D ]/\}}|d u r#qt|t�rI|j rIt|j d t�rI|j d | j |d |j d< d | j |d < qdd� | j D �| _ t� �� t| j | j dd � �D ]3\}}t � }|r�t 1569 |�|v rsn#|� t 1570 |�� t|t �r�|� |fdd�� n |�� }tt|�d �}|slqctd d� | j D ��| _| S ) 1571 Nc s s0 � | ]}t |t�o|jot |jd t�V qdS �r� N)r1 r r r� r r* r* r+ r � s � 1572 �� 1573 �z!And.streamline.<locals>.<genexpr>r� r c S s g | ]}|d ur|�qS r& r* r r* r* r+ r@ � � z"And.streamline.<locals>.<listcomp>c S s t |dt|| ��S )N� parent_anchor)�setattrr� )r� r� r� �cur_r* r* r+ r� 1574 s �z And.streamline.<locals>.<lambda>c s r5 r& r6 r r* r* r+ r r7 )r r" r� r1 r r� rQ re r� r� r� �add� IndentedBlockr r� �nextr� r r� )r( rp r �prev�cur�seen�subsrS r* r+ re � sF ���� � 1575 1576 1577 ���zAnd.streamlinec C s� | j d j|||dd�\}}d}| j dd � D ]X}t|�tju r#d}q|r\z |�|||�\}}W n4 ty8 � tyK } zd |_t�|��d }~w t y[ t|t 1578 |�| j | ��w |�|||�\}}|sk|� � ro||7 }q||fS )Nr Fro r T) r r r� r� r� �ParseSyntaxExceptionrH r� �_from_exceptionr/ r! r� �haskeys) r( r� r� r� � 1579 resultlist� errorStopr � 1580 exprtokensrN r* r* r+ r& s6 1581 1582 � 1583 � �� �z And.parseImplc C � t |t�r 1584 | �|�}| �|�S r& �r1 r" r� r� r� r* r* r+ �__iadd__3 � 1585 1586 1587 z And.__iadd__c C s8 |d d � | g }| j D ] }|�|� |js d S q d S r& )r r� r� r� r* r* r+ r� 8 s 1588 1589 ��zAnd._checkRecursionc C sz d� dd� | jD ��}t|�dkr7|dd t|�d � dkr7|dd� }t|�dkr7|dd t|�d � dks d| d S ) 1590 Nr� c s r 1591 r& r r r* r* r+ r @ r z+And._generateDefaultName.<locals>.<genexpr>r r �{}r� �{�})r� r r! �r( �innerr* r* r+ r� ? s 1592 & &� zAnd._generateDefaultNamer- )r/ r4 r5 rB rg r� r� r r} rs r, re r& rM r� r� r_ r* r* rS r+ r� � s ���! 1593 - r� c �l e Zd ZdZddeje def� fdd� Zdef� fdd � Z dd d �Z 1594 d d� Z dd� Z d� fdd� Z � ZS )r� a� Requires that at least one :class:`ParseExpression` is found. If 1595 two expressions match, the expression that matches the longest 1596 string will be used. May be constructed using the ``'^'`` 1597 operator. 1598 1599 Example:: 1600 1601 # construct Or using '^' operator 1602 1603 number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums)) 1604 print(number.search_string("123 3.1416 789")) 1605 1606 prints:: 1607 1608 [['123'], ['3.1416'], ['789']] 1609 Fr r� c �N t � �||� | jr"tdd� | jD ��| _tdd� | jD ��| _d S d| _d S )Nc s r5 r& r6 r r* r* r+ r \ r7 z Or.__init__.<locals>.<genexpr>c s r5 r& r� r r* r* r+ r ] r7 T�rQ r, r r" r� r r� r# rS r* r+ r, Y � 1610 1611 z Or.__init__rP c s` t � �� | jr+tdd� | jD ��| _tdd� | jD ��| _tdd� | jD ��| _| S d| _| S )Nc s r5 r& r6 r r* r* r+ r d r7 z Or.streamline.<locals>.<genexpr>c s r5 r& �r� r r* r* r+ r e r7 c s �" � | ] }|j o t|t� V qd S r& �r� r1 r� r r* r* r+ r f � � 1612 �F)rQ re r r" r� r� r r� r� rS r* r+ re a s 1613 1614 ��z Or.streamlineTc C sx d}d }g }g }t dd� | jD ��r| �||�}| jD ]q}z 1615 |j||dd�} W n] tyH } 1616 zd | 1617 _|| 1618 _|�| 1619 � d }d}W Y d } 1620 ~ 1621 qd } 1622 ~ 1623 w tyh } z|s^d | _| j |kr^| }| j }W Y d } ~ qd } ~ w t 1624 y� t |�|kr�t|t |�|j | �}t |�}Y qw |�| |f� q|r�|j td�dd� |s�|d d } | �|||�S d } |D ]M\}}|| d kr�| S z |�|||�\} }W n ty� } zd | _| j |kr�| }| j }W Y d } ~ q�d } ~ ww | |kr�| |f S | | d kr�| |f} q�| d kr�| S |�r*t |�dk�r$|j d 1625 d � d � |d j |d j k�r$|j d d � d � |d }|�|d u�r5| j |_|�t||d| ��)Nr� c s r5 r& )r� r r* r* r+ r r r7 z Or.parseImpl.<locals>.<genexpr>T�r> r )r� �reverser r9 c S � | j S r& �r� �r r* r* r+ r� � r� z Or.parseImpl.<locals>.<lambda>�r� c S � | j tt| j�� fS r& �r� r! rs � parserElementr` r* r* r+ r� � r: � no defined alternatives to match)r r r$ r@ r� r� rd r� r� r� r/ r! r� �sortr r r� )r( r� r� r� � maxExcLoc� maxExceptionrw �fatalsr �loc2�pfer: � best_expr�longest�loc1�expr1r� � max_fatalr* r* r+ r& m s� 1626 1627 � 1628 � ��� 1629 �� � 1630 �z Or.parseImplc C rK r& rL r� r* r* r+ �__ixor__� rN z Or.__ixor__c C � dd� dd� | jD �� d S )NrP z ^ c s r 1631 r& r r r* r* r+ r � r z*Or._generateDefaultName.<locals>.<genexpr>rQ �r� r r� r* r* r+ r� � � zOr._generateDefaultNamec �R t jr"tj| jvr"tdd� | jD ��r"tjd�d|t | �j 1632 �dd� t � � ||�S )Nc s �& � | ]}t |t�otj|jvV qd S r& �r1 r� r` rV r� r r* r* r+ r � � � 1633 �� 1634 �z%Or._setResultsName.<locals>.<genexpr>��{}: setting results name {!r} on {} expression will return a list of all parsed tokens in an And alternative, in prior versions only the first token was returned; enclose contained argument in GrouprV r# r/ � rI rV r` r� r" r r1 rL r� r� r/ rQ r� �r( rN r� rS r* r+ r� � �$ ����� zOr._setResultsNamer+ r- )r/ r4 r5 rB r� r r} rs r, re r& rq r� r� r_ r* r* rS r+ r� G s 1635 Rr� c rT )r� a� Requires that at least one :class:`ParseExpression` is found. If 1636 more than one expression matches, the first one listed is the one that will 1637 match. May be constructed using the ``'|'`` operator. 1638 1639 Example:: 1640 1641 # construct MatchFirst using '|' operator 1642 1643 # watch the order of expressions to match 1644 number = Word(nums) | Combine(Word(nums) + '.' + Word(nums)) 1645 print(number.search_string("123 3.1416 789")) # Fail! -> [['123'], ['3'], ['1416'], ['789']] 1646 1647 # put more selective expression first 1648 number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums) 1649 print(number.search_string("123 3.1416 789")) # Better -> [['123'], ['3.1416'], ['789']] 1650 Fr r� c rU )Nc s r5 r& r6 r r* r* r+ r � r7 z&MatchFirst.__init__.<locals>.<genexpr>c s r5 r& r� r r* r* r+ r � r7 TrV r# rS r* r+ r, � rW zMatchFirst.__init__rP c sp | j r| S t� �� | jr0tdd� | jD ��| _tdd� | jD ��| _tdd� | jD ��| _| S d| _d| _| S )Nc s r5 r& rX r r* r* r+ r r7 z(MatchFirst.streamline.<locals>.<genexpr>c s r5 r& r6 r r* r* r+ r r7 c s rY r& rZ r r* r* r+ r r[ FT) r� rQ re r r" r� r� r r� r� rS r* r+ re � s 1651 1652 ��zMatchFirst.streamlineTc C s� d}d }| j D ]V}z 1653 |�|||�W S ty& } zd |_||_� d }~w tyA } z|j|kr7|}|j}W Y d }~qd }~w ty] t|�|kr[t|t|�|j | �}t|�}Y qw |d urh| j |_ 1654 |�t||d| ��)Nr� re ) r r r� r� rd r� r� r/ r! r� r� ) r( r� r� r� rg rh r rk r: r* r* r+ r& sB 1655 1656 �� 1657 � ����zMatchFirst.parseImplc C rK r& rL r� r* r* r+ �__ior__. rN zMatchFirst.__ior__c C rr )NrP z | c s r 1658 r& r r r* r* r+ r 4 r z2MatchFirst._generateDefaultName.<locals>.<genexpr>rQ rs r� r* r* r+ r� 3 rt z MatchFirst._generateDefaultNamec ru )Nc s rv r& rw r r* r* r+ r < rx z-MatchFirst._setResultsName.<locals>.<genexpr>ry rV r# r/ rz r{ rS r* r+ r� 6 r| zMatchFirst._setResultsNamer+ r- )r/ r4 r5 rB r� r r} rs r, re r& r} r� r� r_ r* r* rS r+ r� � s 1659 "r� c sV e Zd ZdZddeje def� fdd� Zdef� fdd � Z dd 1660 d �Z 1661 d d � Z � Z S )r� al Requires all given :class:`ParseExpression` s to be found, but in 1662 any order. Expressions may be separated by whitespace. 1663 1664 May be constructed using the ``'&'`` operator. 1665 1666 Example:: 1667 1668 color = one_of("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN") 1669 shape_type = one_of("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON") 1670 integer = Word(nums) 1671 shape_attr = "shape:" + shape_type("shape") 1672 posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn") 1673 color_attr = "color:" + color("color") 1674 size_attr = "size:" + integer("size") 1675 1676 # use Each (using operator '&') to accept attributes in any order 1677 # (shape and posn are required, color and size are optional) 1678 shape_spec = shape_attr & posn_attr & Opt(color_attr) & Opt(size_attr) 1679 1680 shape_spec.run_tests(''' 1681 shape: SQUARE color: BLACK posn: 100, 120 1682 shape: CIRCLE size: 50 color: BLUE posn: 50,80 1683 color:GREEN size:20 shape:TRIANGLE posn:20,40 1684 ''' 1685 ) 1686 1687 prints:: 1688 1689 shape: SQUARE color: BLACK posn: 100, 120 1690 ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']] 1691 - color: BLACK 1692 - posn: ['100', ',', '120'] 1693 - x: 100 1694 - y: 120 1695 - shape: SQUARE 1696 1697 1698 shape: CIRCLE size: 50 color: BLUE posn: 50,80 1699 ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']] 1700 - color: BLUE 1701 - posn: ['50', ',', '80'] 1702 - x: 50 1703 - y: 80 1704 - shape: CIRCLE 1705 - size: 50 1706 1707 1708 color: GREEN size: 20 shape: TRIANGLE posn: 20,40 1709 ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']] 1710 - color: GREEN 1711 - posn: ['20', ',', '40'] 1712 - x: 20 1713 - y: 40 1714 - shape: TRIANGLE 1715 - size: 20 1716 Tr r� c sH t � �||� | jrtdd� | jD ��| _nd| _d| _d| _d| _d S )Nc s r5 r& r6 r r* r* r+ r � r7 z Each.__init__.<locals>.<genexpr>T)rQ r, r r r� r� �initExprGroupsr� r# rS r* r+ r, � s 1717 z Each.__init__rP c s4 t � �� | jrtdd� | jD ��| _| S d| _| S )Nc s r5 r& r6 r r* r* r+ r � r7 z"Each.streamline.<locals>.<genexpr>T)rQ re r r r� r� rS r* r+ re � s 1718 �zEach.streamlinec s� | j rItdd� | jD ��| _dd� | jD �}dd� | jD �}|| | _dd� | jD �| _dd� | jD �| _dd� | jD �| _| j| j7 _d | _ |}| jd d � }| jd d � � | jd d � }g } d 1719 } 1720 g } g } | 1721 r�|� | } | �� | �� | D ][}z 1722 |j ||d 1723 d �}W n/ t 1724 y� } zd |_ ||_ | � |� | � |� W Y d }~qzd }~w ty� | � |� Y qzw | � | j�t|�|�� ||v r�|�|� qz|� v rՈ �|� qzt| �t| �kr�d } 1725 | 1726 sj| �r t| �d k�r| jd d� d� | d j| d jk�r| jdd� d� | d }|�|�r#d�dd� |D ��}t||d�|���| � fdd�| jD �7 } tg �}| D ]}|�|||�\}}||7 }�q5||fS )Nc s s( � | ]}t |t�rt|j�|fV qd S r& )r1 r� r� r� r r* r* r+ r � s � 1727 � 1728 �z!Each.parseImpl.<locals>.<genexpr>c S s g | ] 1729 }t |t�r|j�qS r* �r1 r� r� r r* r* r+ r@ � � z"Each.parseImpl.<locals>.<listcomp>c S s& g | ]}|j rt|tttf�s|�qS r* )r� r1 r� r� r� r r* r* r+ r@ � s ���c S �( g | ]}t |t�r|jj|jd d��qS �T)r� )r1 �_MultipleMatchr� r� r� r r* r* r+ r@ � � ��c S r� r� )r1 r� r� r� r� r r* r* r+ r@ � r� c S s g | ] }t |tttf�s|�qS r* )r1 r� r� r� r r* r* r+ r@ � s 1730 ��FTr\ r c S r^ r& r_ r` r* r* r+ r� � r� z Each.parseImpl.<locals>.<lambda>ra r c S rb r& rc r` r* r* r+ r� � r: z, c S r r* r r r* r* r+ r@ � r z*Missing one or more required elements ({})c s$ g | ]}t |t�r|j� v r|�qS r* r r ��tmpOptr* r+ r@ � s $ )r~ �dictr �opt1map� optionals�multioptionals� multirequired�requiredrR r@ r� r� rd r� r� r r� �remover! rf r� r� r� r r )r( r� r� r� �opt1�opt2�tmpLoc�tmpReqd�multis� 1731 matchOrder� keepMatching�failedri �tmpExprsr rk rp �missing� total_resultsr� r* r� r+ r& � s� 1732 �� 1733 ��� 1734 � � 1735 ��� zEach.parseImplc C rr )NrP z & c s r 1736 r& r r r* r* r+ r � r z,Each._generateDefaultName.<locals>.<genexpr>rQ rs r� r* r* r+ r� � rt zEach._generateDefaultNamer- ) r/ r4 r5 rB r� r r} rs r, re r& r� r_ r* r* rS r+ r� Q s 9 1737 1738 Wr� c s� e Zd ZdZd deeef def� fdd� Zde e fdd �Z 1739 d d d �Z d d edef� fdd� Z d d edef� fdd� Z def� fdd� Zdef� fdd� Zdd� Zd d dd�Zdd � Ze Ze Z� ZS )!�ParseElementEnhancezfAbstract subclass of :class:`ParserElement`, for combining and 1740 post-processing parsed tokens. 1741 Fr� r� c s� t � �|� t|t�r+t| jt�r| �|�}ntt| �| j�r$t|�}n| �t|��}|| _ |d urX|j 1742 | _ 1743 |j | _ | j |j |jd� |j| _|j| _|j| _| j�|j� d S d S )Nr )rQ r, r1 r" � 1744 issubclassr� r` r� r r� r� r� r� r� r� r� r� r� r� r� �r( r� r� rS r* r+ r, � s& 1745 1746 ��z ParseElementEnhance.__init__rP c C s | j d ur | j gS g S r& �r� r� r* r* r+ r� r zParseElementEnhance.recurseTc C s, | j d ur| j j|||dd�S t||d| ��)NFro zNo expression defined)r� r r� r% r* r* r+ r& s 1747 z ParseElementEnhance.parseImplr� c �6 t � �|� |r| j�� | _| jd ur| j�|� | S r& )rQ r� r� r� r� rS r* r+ r� � 1748 z$ParseElementEnhance.leave_whitespacec r� r& )rQ r� r� r� r� rS r* r+ r� $ r� z%ParseElementEnhance.ignore_whitespacec sl t |t�r || jvr t� �|� | jd ur | j�| jd � | S t� �|� | jd ur4| j�| jd � | S r( )r1 r� r� rQ r� r� r� rS r* r+ r� - r) zParseElementEnhance.ignorec s" t � �� | jd ur| j�� | S r& )rQ re r� r� rS r* r+ re 9 s 1749 1750 1751 z ParseElementEnhance.streamlinec C sF | |v r t || g ��|d d � | g }| jd ur!| j�|� d S d S r& )�RecursiveGrammarExceptionr� r� )r( r� r� r* r* r+ r� ? s 1752 �z#ParseElementEnhance._checkRecursionNc C sB |d u rg }|d d � | g }| j d ur| j �|� | �g � d S r& �r� r� r� �r( r� r, r* r* r+ r� F s 1753 z ParseElementEnhance.validatec C r* r+ )r� r� r/ rs r� r� r* r* r+ r� N r z(ParseElementEnhance._generateDefaultNamer+ r- r& rU )r/ r4 r5 rB r r} rs rs r, r r� r& r� r� r� re r� r� r� rO rP r_ r* r* rS r+ r� � s 1754 r� c s` e Zd ZdZG dd� de�ZG dd� de�Zddd�d ed 1755 ed ef� fd d �Z ddd�Z 1756 � Z S )r? z� 1757 Expression to match one or more expressions at a given indentation level. 1758 Useful for parsing text where structure is implied by indentation (like Python source code). 1759 c �" e Zd Zdef� fdd� Z� ZS )zIndentedBlock._Indent�ref_colc �, t � �� d�� �| _| �� fdd�� d S )Nz expected indent at column {}c s t || �� kS r& �r� r� �r� r* r+ r� _ � z0IndentedBlock._Indent.__init__.<locals>.<lambda>�rQ r, r� r� r �r( r� rS r� r+ r, \ � 1760 z IndentedBlock._Indent.__init__�r/ r4 r5 r� r, r_ r* r* rS r+ �_Indent[ � r� c r� )z IndentedBlock._IndentGreaterr� c r� )Nz)expected indent at column greater than {}c s t || �� kS r& r� r� r� r* r+ r� e r� z7IndentedBlock._IndentGreater.__init__.<locals>.<lambda>r� r� rS r� r+ r, b r� z%IndentedBlock._IndentGreater.__init__r� r* r* rS r+ �_IndentGreatera r� r� FT�r� �groupedr� r� r� c s& t � j|dd� || _|| _d| _d S )NTra r )rQ r, � 1761 _recursive�_groupedr; )r( r� r� r� rS r* r+ r, g s 1762 zIndentedBlock.__init__c C s� t � �||�}| j�|||� t||�}| �|�}t � | | j }| jrD| �|�}t| j| j| j d�} | � 1763 | j � || _ |t || �7 }|�dtt|��dd � �� � d|� �� t|�} 1764 | �| j �t� B } | j rlt} ndd� } | | 1765 �t| � �|||�S )Nr� zinner ������@c S � | S r& r* r� r* r* r+ r� � r� z)IndentedBlock.parseImpl.<locals>.<lambda>)rg r$ r� r@ r� r� r� r� r? r� r� r� r; r� r� �hexr� r~ r� rh �Groupr� r& ) r( r� r� r� � 1766 anchor_loc� 1767 indent_col�peer_detect_expr� 1768 inner_expr� 1769 sub_indent� nested_block�block�trailing_undentr� r* r* r+ r& q s, 1770 1771 1772 � *�zIndentedBlock.parseImplr- ) r/ r4 r5 rB rg r� r� r} rs r, r& r_ r* r* rS r+ r? U s ���� 1773 r? c �< e Zd ZdZdeeef f� fdd� Zd� fdd� Z� Z S ) � AtStringStartz�Matches if expression matches at the beginning of the parse 1774 string:: 1775 1776 AtStringStart(Word(nums)).parse_string("123") 1777 # prints ["123"] 1778 1779 AtStringStart(Word(nums)).parse_string(" 123") 1780 # raises ParseException 1781 r� c � t � �|� d| _d S �NF�rQ r, r� �r( r� rS r* r+ r, � � 1782 zAtStringStart.__init__Tc s$ |dkr 1783 t ||d��t� �|||�S )Nr znot found at string start)r� rQ r& r% rS r* r+ r& � s zAtStringStart.parseImplr- � 1784 r/ r4 r5 rB r r} rs r, r& r_ r* r* rS r+ r� � s 1785 r� c r� ) � AtLineStarta� Matches if an expression matches at the beginning of a line within 1786 the parse string 1787 1788 Example:: 1789 1790 test = '''\ 1791 AAA this line 1792 AAA and this line 1793 AAA but not this one 1794 B AAA and definitely not this one 1795 ''' 1796 1797 for t in (AtLineStart('AAA') + restOfLine).search_string(test): 1798 print(t) 1799 1800 prints:: 1801 1802 ['AAA', ' this line'] 1803 ['AAA', ' and this line'] 1804 1805 r� c r� r� r� r� rS r* r+ r, � r� zAtLineStart.__init__Tc s* t ||�dkr t||d��t� �|||�S )Nr znot found at line start)r� r� rQ r& r% rS r* r+ r& � s zAtLineStart.parseImplr- r� r* r* rS r+ r� � s r� c s8 e Zd ZdZdeeef f� fdd� Zddd�Z� Z S ) � 1806 FollowedByac Lookahead matching of the given parse expression. 1807 ``FollowedBy`` does *not* advance the parsing position within 1808 the input string, it only verifies that the specified parse 1809 expression matches at the current position. ``FollowedBy`` 1810 always returns a null token list. If any results names are defined 1811 in the lookahead expression, those *will* be returned for access by 1812 name. 1813 1814 Example:: 1815 1816 # use FollowedBy to match a label only if it is followed by a ':' 1817 data_word = Word(alphas) 1818 label = data_word + FollowedBy(':') 1819 attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join)) 1820 1821 attr_expr[1, ...].parse_string("shape: SQUARE color: BLACK posn: upper left").pprint() 1822 1823 prints:: 1824 1825 [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']] 1826 r� c r� r� �rQ r, r� r� rS r* r+ r, � r� zFollowedBy.__init__Tc C s( | j j|||d�\}}|d d �= ||fS )Nr? )r� r )r( r� r� r� r: r2 r* r* r+ r& � s 1827 zFollowedBy.parseImplr- r� r* r* rS r+ r� � s r� c sF e Zd ZdZ d deeef deje f� fdd� Z 1828 d d d 1829 �Z � Z S ) � 1830 PrecededBya� Lookbehind matching of the given parse expression. 1831 ``PrecededBy`` does not advance the parsing position within the 1832 input string, it only verifies that the specified parse expression 1833 matches prior to the current position. ``PrecededBy`` always 1834 returns a null token list, but if a results name is defined on the 1835 given expression, it is returned. 1836 1837 Parameters: 1838 1839 - expr - expression that must match prior to the current parse 1840 location 1841 - retreat - (default= ``None``) - (int) maximum number of characters 1842 to lookbehind prior to the current parse location 1843 1844 If the lookbehind expression is a string, :class:`Literal`, 1845 :class:`Keyword`, or a :class:`Word` or :class:`CharsNotIn` 1846 with a specified exact or maximum length, then the retreat 1847 parameter is not required. Otherwise, retreat must be specified to 1848 give a maximum number of characters to look back from 1849 the current parse position for a lookbehind match. 1850 1851 Example:: 1852 1853 # VB-style variable names with type prefixes 1854 int_var = PrecededBy("#") + pyparsing_common.identifier 1855 str_var = PrecededBy("$") + pyparsing_common.identifier 1856 1857 Nr� �retreatc s� t � �|� | �� �� | _d| _d| _d| _t|t�r#t |�}d| _n+t|t 1858 t f�r1|j }d| _n t|t tf�rD|jtkrD|j}d| _n 1859 t|t�rNd}d| _|| _dt|� | _d| _| j�dd� � d S )NTFr znot preceded by c S s |� td d ��S r& )� __delitem__�slicer� r* r* r+ r� $ s z%PrecededBy.__init__.<locals>.<lambda>)rQ r, r� r� r� r� r� r1 r" r! r rx rn r� r� r� r4 r r� rs r� r� r� r� )r( r� r� rS r* r+ r, s* 1860 1861 zPrecededBy.__init__r Tc C s� | j r!|| jk rt||| j��|| j }| j�||�\}}||fS | jt� }|td|| j �|� }t||| j�} tdt || jd �d �D ])} 1862 z|�|t 1863 |�| 1864 �\}}W n t yk } z| } W Y d } ~ qGd } ~ ww ||fS | �r ) r� r� r� r� r� r rh r� r� rr r! rH ) r( r� r� r� rp r: r2 � test_expr�instring_slice� last_expr�offset�pber* r* r+ r& & s* 1865 1866 � ����zPrecededBy.parseImplr& )r T) r/ r4 r5 rB r r} rs r� r� r� r, r& r_ r* r* rS r+ r� � s � 1867 ��r� c @ s e Zd ZdZddd�ZdS )�Locateda� 1868 Decorates a returned token with its starting and ending 1869 locations in the input string. 1870 1871 This helper adds the following results names: 1872 1873 - ``locn_start`` - location where matched expression begins 1874 - ``locn_end`` - location where matched expression ends 1875 - ``value`` - the actual parsed results 1876 1877 Be careful if the input text contains ``<TAB>`` characters, you 1878 may want to call :class:`ParserElement.parse_with_tabs` 1879 1880 Example:: 1881 1882 wd = Word(alphas) 1883 for match in Located(wd).search_string("ljsdf123lksdjjf123lkkjj1222"): 1884 print(match) 1885 1886 prints:: 1887 1888 [0, ['ljsdf'], 5] 1889 [8, ['lksdjjf'], 15] 1890 [18, ['lkkjj'], 23] 1891 1892 Tc C sZ |}| j j|||dd�\}}t|||g�}||d< ||d< ||d< | jr)||gfS ||fS )NFro � 1893 locn_startrM �locn_end)r� r r r� )r( r� r� r� rp r9 r; r* r* r+ r& \ s 1894 zLocated.parseImplNr- )r/ r4 r5 rB r& r* r* r* r+ r� @ s r� c s@ e Zd ZdZdeeef f� fdd� Zd 1895 dd�Zdd � Z � Z 1896 S ) r� a� 1897 Lookahead to disallow matching with the given parse expression. 1898 ``NotAny`` does *not* advance the parsing position within the 1899 input string, it only verifies that the specified parse expression 1900 does *not* match at the current position. Also, ``NotAny`` does 1901 *not* skip over leading whitespace. ``NotAny`` always returns 1902 a null token list. May be constructed using the ``'~'`` operator. 1903 1904 Example:: 1905 1906 AND, OR, NOT = map(CaselessKeyword, "AND OR NOT".split()) 1907 1908 # take care not to mistake keywords for identifiers 1909 ident = ~(AND | OR | NOT) + Word(alphas) 1910 boolean_term = Opt(NOT) + ident 1911 1912 # very crude boolean expression - to support parenthesis groups and 1913 # operation hierarchy, use infix_notation 1914 boolean_expr = boolean_term + ((AND | OR) + boolean_term)[...] 1915 1916 # integers that are followed by "." are actually floats 1917 integer = Word(nums) + ~Char(".") 1918 r� c s, t � �|� d| _d| _dt| j� | _d S )NFTzFound unwanted token, )rQ r, r� r� rs r� r� r� rS r* r+ r, � s zNotAny.__init__Tc C s& | j �||�rt||| j| ��|g fS r& )r� rA r� r� r% r* r* r+ r& � s zNotAny.parseImplc C � dt | j� d S )Nz~{rQ �rs r� r� r* r* r+ r� � rc zNotAny._generateDefaultNamer- ) r/ r4 r5 rB r r} rs r, r& r� r_ r* r* rS r+ r� j s 1919 1920 r� c sv e Zd Z ddd�dedejeeef dejeeef f� fdd�Zdefd d 1921 �Z dd d �Z 1922 d� fdd� Z � Z S )r� N��stopOnr� �stop_onr� c s@ t � �|� |p |}d| _|}t|t�r| �|�}| �|� d S r� )rQ r, r� r1 r" r� r� )r( r� r� r� �enderrS r* r+ r, � s 1923 1924 z_MultipleMatch.__init__rP c C s2 t |t�r 1925 | �|�}|d ur| | _| S d | _| S r& )r1 r" r� � not_ender)r( r� r* r* r+ r� � s 1926 1927 �z_MultipleMatch.stopOnTc C s� | j j}| j}| jd u}|r| jj}|r|||� ||||�\}}z*| j } |r/|||� | r7|||�} 1928 n|} 1929 ||| 1930 |�\}} | sG| �� rK|| 7 }q( ttfyY Y ||fS w r& ) r� r r r� r? r� rG r� r/ ) r( r� r� r� �self_expr_parse�self_skip_ignorables� check_ender� try_not_enderr9 �hasIgnoreExprsrx � tmptokensr* r* r+ r& � s0 1931 1932 1933 1934 � 1935 �z_MultipleMatch.parseImplFc sv t jr4tj| jvr4| jg| j�� D ]!}t|t�r3|jr3tj|jvr3t j 1936 d� d|t | �j |j�dd� qt� �||�S r. )rI rW r` r� r� r� r1 r} r� r1 rL r� r� r/ rQ r� r2 rS r* r+ r� � s2 �������� z _MultipleMatch._setResultsNamer& r- r+ ) r/ r4 r5 r} r� r� r rs r, r� r& r� r_ r* r* rS r+ r� � s ����� 1937 r� c @ s e Zd ZdZdd� ZdS )r� ar 1938 Repetition of one or more of the given expression. 1939 1940 Parameters: 1941 - expr - expression that must match one or more times 1942 - stop_on - (default= ``None``) - expression for a terminating sentinel 1943 (only required if the sentinel would ordinarily match the repetition 1944 expression) 1945 1946 Example:: 1947 1948 data_word = Word(alphas) 1949 label = data_word + FollowedBy(':') 1950 attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).set_parse_action(' '.join)) 1951 1952 text = "shape: SQUARE posn: upper left color: BLACK" 1953 attr_expr[1, ...].parse_string(text).pprint() # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']] 1954 1955 # use stop_on attribute for OneOrMore to avoid reading label string as part of the data 1956 attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join)) 1957 OneOrMore(attr_expr).parse_string(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']] 1958 1959 # could also be written as 1960 (attr_expr * (1,)).parse_string(text).pprint() 1961 c C r� )NrP z}...r� r� r* r* r+ r� � rc z OneOrMore._generateDefaultNameN)r/ r4 r5 rB r� r* r* r* r+ r� � s r� c sj e Zd ZdZ ddd�dedejeeef dejeeef f� fdd�Z d� fd 1962 d � Z 1963 d d � Z � Z S )r� ao 1964 Optional repetition of zero or more of the given expression. 1965 1966 Parameters: 1967 - ``expr`` - expression that must match zero or more times 1968 - ``stop_on`` - expression for a terminating sentinel 1969 (only required if the sentinel would ordinarily match the repetition 1970 expression) - (default= ``None``) 1971 1972 Example: similar to :class:`OneOrMore` 1973 Nr� r� r� r� c s t � j||p|d� d| _d S )Nr� Tr� )r( r� r� r� rS r* r+ r, s 1974 zZeroOrMore.__init__Tc s< z t � �|||�W S ttfy |tg | jd�f Y S w )Nr� )rQ r& r� r/ r r� r% rS r* r+ r& s 1975 �zZeroOrMore.parseImplc C r� )N�[z]...r� r� r* r* r+ r� rc z ZeroOrMore._generateDefaultNamer& r- ) r/ r4 r5 rB r} r� r� r rs r, r& r� r_ r* r* rS r+ r� s ����� 1976 r� c @ s e Zd Zdd� Zdd� ZdS )� 1977 _NullTokenc C r� r� r* r� r* r* r+ �__bool__$ r+ z_NullToken.__bool__c C r� r� r* r� r* r* r+ r� ' r+ z_NullToken.__str__N)r/ r4 r5 r� r� r* r* r* r+ r� # s r� c sN e Zd ZdZe� Zefdeeef de f� fdd� Z 1978 d dd�Z d d 1979 � Z � Z S ) r� aN 1980 Optional matching of the given expression. 1981 1982 Parameters: 1983 - ``expr`` - expression that must match zero or more times 1984 - ``default`` (optional) - value to be returned if the optional expression is not found. 1985 1986 Example:: 1987 1988 # US postal code can be a 5-digit zip, plus optional 4-digit qualifier 1989 zip = Combine(Word(nums, exact=5) + Opt('-' + Word(nums, exact=4))) 1990 zip.run_tests(''' 1991 # traditional ZIP code 1992 12345 1993 1994 # ZIP+4 form 1995 12101-0001 1996 1997 # invalid ZIP 1998 98765- 1999 ''') 2000 2001 prints:: 2002 2003 # traditional ZIP code 2004 12345 2005 ['12345'] 2006 2007 # ZIP+4 form 2008 12101-0001 2009 ['12101-0001'] 2010 2011 # invalid ZIP 2012 98765- 2013 ^ 2014 FAIL: Expected end of text (at char 5), (line:1, col:6) 2015 r� �defaultc s* t � j|dd� | jj| _|| _d| _d S )NFra T)rQ r, r� r� � defaultValuer� )r( r� r� rS r* r+ r, T s 2016 2017 z Opt.__init__Tc C s� | j }z|j|||dd�\}}W ||fS ttfyG | j}|| jur6|jr2t|g�}|||j< n|g}ng }Y ||fS Y ||fS Y ||fS w )NFro )r� r r� r/ r� �_Opt__optionalNotMatchedr� r )r( r� r� r� � self_exprr9 � default_valuer* r* r+ r& \ s$ � 2018 2019 ���z Opt.parseImplc C sn t | j�}t|�dkr1|dd t|�d � dkr1|dd� }t|�dkr1|dd t|�d � dksd| d S )Nr r rO r� r� �])rs r� r! rR r* r* r+ r� l s 2020 2021 & &� zOpt._generateDefaultNamer- )r/ r4 r5 rB r� r� r r} rs r r, r& r� r_ r* r* rS r+ r� + s &� 2022 �� 2023 r� c sl e Zd ZdZ ddd�deeef dededej eeef d eeef f 2024 � fd 2025 d �Z 2026 dd d�Z � Z S )r� a* 2027 2028 Token for skipping over all undefined text until the matched 2029 expression is found. 2030 2031 Parameters: 2032 - ``expr`` - target expression marking the end of the data to be skipped 2033 - ``include`` - if ``True``, the target expression is also parsed 2034 (the skipped text and target expression are returned as a 2-element 2035 list) (default= ``False``). 2036 - ``ignore`` - (default= ``None``) used to define grammars (typically quoted strings and 2037 comments) that might contain false matches to the target expression 2038 - ``fail_on`` - (default= ``None``) define expressions that are not allowed to be 2039 included in the skipped test; if found before the target expression is found, 2040 the :class:`SkipTo` is not a match 2041 2042 Example:: 2043 2044 report = ''' 2045 Outstanding Issues Report - 1 Jan 2000 2046 2047 # | Severity | Description | Days Open 2048 -----+----------+-------------------------------------------+----------- 2049 101 | Critical | Intermittent system crash | 6 2050 94 | Cosmetic | Spelling error on Login ('log|n') | 14 2051 79 | Minor | System slow when running too many reports | 47 2052 ''' 2053 integer = Word(nums) 2054 SEP = Suppress('|') 2055 # use SkipTo to simply match everything up until the next SEP 2056 # - ignore quoted strings, so that a '|' character inside a quoted string does not match 2057 # - parse action will call token.strip() for each matched token, i.e., the description body 2058 string_data = SkipTo(SEP, ignore=quoted_string) 2059 string_data.set_parse_action(token_map(str.strip)) 2060 ticket_expr = (integer("issue_num") + SEP 2061 + string_data("sev") + SEP 2062 + string_data("desc") + SEP 2063 + integer("days_open")) 2064 2065 for tkt in ticket_expr.search_string(report): 2066 print tkt.dump() 2067 2068 prints:: 2069 2070 ['101', 'Critical', 'Intermittent system crash', '6'] 2071 - days_open: '6' 2072 - desc: 'Intermittent system crash' 2073 - issue_num: '101' 2074 - sev: 'Critical' 2075 ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14'] 2076 - days_open: '14' 2077 - desc: "Spelling error on Login ('log|n')" 2078 - issue_num: '94' 2079 - sev: 'Cosmetic' 2080 ['79', 'Minor', 'System slow when running too many reports', '47'] 2081 - days_open: '47' 2082 - desc: 'System slow when running too many reports' 2083 - issue_num: '79' 2084 - sev: 'Minor' 2085 FN)�failOnr� �includer� �fail_onr� c sd t � �|� |p |}|| _d| _d| _|| _d| _t|t�r%| � |�| _ 2086 n|| _ 2087 dt | j � | _ d S )NTFzNo match found for )rQ r, � 2088 ignoreExprr� r� � includeMatchr� r1 r" r� r� rs r� r� )r( r� r� r� r� r� rS r* r+ r, � s 2089 zSkipTo.__init__Tc C s |}t |�}| jj}| jd ur| jjnd }| jd ur | jjnd }|} | |krf|d ur0||| �r0n>|d urG z||| �} W n tyE Y nw q5z 2090 ||| ddd� W n tt fy` | d7 } Y nw n | |ks&t||| j 2091 | ��| }|||� } 2092 t | 2093 �} | j r�||||dd�\}} | | 7 } || fS )Nr F)r� r ro ) r! r� r r� r@ r� r? rH r� r/ r� r r� ) r( r� r� r� r� r" r� �self_failOn_canParseNext�self_ignoreExpr_tryParse�tmploc�skiptext� 2094 skipresultr� r* r* r+ r& � sF �� 2095 �� �� zSkipTo.parseImpl)FNNr- ) r/ r4 r5 rB r r} rs rs r� r� r, r& r_ r* r* rS r+ r� w s& ?�� 2096 ���� 2097 �r� c s� e Zd ZdZd"dejeeef f� fdd� Z dd� Z 2098 dd � Z � fd 2099 d �Z d d � Z d#� fdd� Zd#dedefdd�Zd#dedefdd�Zdefdd�Zd"d$dd�Zdd � Zdef� fd d � Zd%� fd d!� ZeZeZ� ZS )&rB aw 2100 Forward declaration of an expression to be defined later - 2101 used for recursive grammars, such as algebraic infix notation. 2102 When the expression is known, it is assigned to the ``Forward`` 2103 variable using the ``'<<'`` operator. 2104 2105 Note: take care when assigning to ``Forward`` not to overlook 2106 precedence of operators. 2107 2108 Specifically, ``'|'`` has a lower precedence than ``'<<'``, so that:: 2109 2110 fwd_expr << a | b | c 2111 2112 will actually be evaluated as:: 2113 2114 (fwd_expr << a) | b | c 2115 2116 thereby leaving b and c out as parseable alternatives. It is recommended that you 2117 explicitly group the values inserted into the ``Forward``:: 2118 2119 fwd_expr << (a | b | c) 2120 2121 Converting to use the ``'<<='`` operator instead will avoid this problem. 2122 2123 See :class:`ParseResults.pprint` for an example of a recursive 2124 parser created using ``Forward``. 2125 Nr� c s, t jdd�d | _t� j|dd� d | _d S )Nra r� r Fra )r� r� � caller_framerQ r, � lshift_liner� rS r* r+ r, s 2126 zForward.__init__c C s� t | d�r| `t|t�r| �|�}|| _| jj| _| jj| _| j| jj | jj 2127 d� | jj | _ | jj | _ | j �| jj � tjdd�d | _| S )Nr� r ra r� �����)r r� r1 r" r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r* r* r+ � 2128 __lshift__ s 2129 2130 2131 2132 2133 � 2134 2135 zForward.__lshift__c C s | |> S r& r* r� r* r* r+ � __ilshift__0 r' zForward.__ilshift__c sJ t jdd�d }tjr || jkr tj| jvr tjddd� t � � 2136 |�}|S )Nra r� r� z<using '<<' operator with '|' is probably an error, use '<<='r/ ) r� r� rI r\ r� r` r� r1 rL rQ r� )r( r� � caller_liner2 rS r* r+ r� 3 s � 2137 �� zForward.__or__c C sF | j d u r tjr tj| jvr!tjdt| jj | jj 2138 d� d S d S d S d S )NzIForward defined here but no expression attached later using '<<=' or '<<')�filenamer� ) r� rI rZ r` r� r1 � warn_explicit� UserWarningr� r� r� r� r* r* r+ �__del__B s 2139 � 2140 ��zForward.__del__Tc sX | j d u r9tjr9tj| jvr9g d�}tjdd�}tt|�dd�D ]\}}|j |v r/|d } nq d}t 2141 j d|d� t j sDt� �|||�S t j�� t j} z | || |f \} 2142 } t| t�r\| �| 2143 | �� fW W d � S t�y || d f} || d 2144 f} |d t||d | �f \} 2145 }| | < |r�| | | | < z t� �||d 2146 �\}}W n ty� t|t�r�� | 2147 |}}Y nw || 2148 kr�|r�| | \} 2149 } | | < | | = | | = | 2150 | �� f Y W d � S | | = | 2151 |�� f Y W d � S |�rz t� �||d �| | < W n t�y } z ||f | | < | | < � d }~ww ||f \} 2152 }| | < q�w 1 �s%w Y d S ) N)rk r{ r� r� �� r� r )rp ra zGForward expression was never assigned a value, will not parse any inputr/ TFz#Forward recursion without base case)r� rI rY r` r� r� r� r� �reversedrN r1 rL r} rT rQ r& r2 rC r1 r0 r� �KeyErrorr� )r( r� r� r� � parse_fnsr� rp �frmr0 �memo�prev_loc� prev_result�act_key�peek_key� prev_peek�new_loc�new_peekr rS r* r+ r& P s� 2153 �� 2154 �� 2155 � 2156 2157 �� 2158 � �%�)�����zForward.parseImplr� rP c C r� r� r� r� r* r* r+ r� � � zForward.leave_whitespacec C r� r� r� r� r* r* r+ r� � r zForward.ignore_whitespacec C s$ | j sd| _ | jd ur| j�� | S r� )r� r� re r� r* r* r+ re � s 2159 2160 2161 zForward.streamlinec C sJ |d u rg }| |vr |d d � | g }| j d ur | j �|� | �g � d S r& r� r� r* r* r+ r� � s 2162 zForward.validatec C sn d| _ d}z#| jd urt| j�d d� }n d}W | jjd | S W | jjd | S | jjd | Y S )Nz: ...rU i� �Nonez: )r� r� rs r� r/ )r( � retStringr* r* r+ r� � s 2163 �,z Forward._generateDefaultNamec s& | j d ur 2164 t� �� S t� }|| K }|S r& )r� rQ r� rB r- rS r* r+ r� � s 2165 2166 2167 z Forward.copyFc sH t jr tj| jvr | jd u r tjd�d|t| �j �dd� t 2168 � � ||�S )NzO{}: setting results name {!r} on {} expression that has no contained expressionrX r# r/ ) rI rX r` r� r� r1 rL r� r� r/ rQ r� )r( rN r� rS r* r+ r� � s �� 2169 ��zForward._setResultsNamer& r- rU r+ )r/ r4 r5 rB r� r� r r} rs r, r� r� r� r r& rs r� r� re r� r� r� r� rO rP r_ r* r* rS r+ rB � s" " _ 2170 rB c s0 e Zd ZdZddeeef f� fdd� Z� ZS )�TokenConverterzW 2171 Abstract subclass of :class:`ParseExpression`, for converting parsed results. 2172 Fr� c r� r� )rQ r, r� r� rS r* r+ r, � r� zTokenConverter.__init__r+ ) r/ r4 r5 rB r r} rs r, r_ r* r* rS r+ r � s $r c s^ e Zd ZdZ ddd�dededed eje f� fd 2173 d �Z d ef� fd d� Z 2174 dd� Z � Z S )�Combinea� Converter to concatenate all matching tokens to a single string. 2175 By default, the matching patterns must also be contiguous in the 2176 input string; this can be disabled by specifying 2177 ``'adjacent=False'`` in the constructor. 2178 2179 Example:: 2180 2181 real = Word(nums) + '.' + Word(nums) 2182 print(real.parse_string('3.1416')) # -> ['3', '.', '1416'] 2183 # will also erroneously match the following 2184 print(real.parse_string('3. 1416')) # -> ['3', '.', '1416'] 2185 2186 real = Combine(Word(nums) + '.' + Word(nums)) 2187 print(real.parse_string('3.1416')) # -> ['3.1416'] 2188 # no match when there are internal spaces 2189 print(real.parse_string('3. 1416')) # -> Exception: Expected W:(0123...) 2190 rr TN)� 2191 joinStringr� � join_string�adjacentr c sD t � �|� |d ur |n|}|r| �� || _d| _|| _d| _d S r� )rQ r, r� r r� r r� )r( r� r r r rS r* r+ r, s 2192 zCombine.__init__rP c s& | j r t�| |� | S t� �|� | S r& )r r} r� rQ r� rS r* r+ r� " s 2193 �zCombine.ignorec C sL |� � }|d d �= |td�|�| j��g| jd�7 }| jr$|�� r$|gS |S )Nrr )r. )r� r r� � _asStringListr r� r� rG )r( r� r� r) �retToksr* r* r+ r* ) s 2194 �zCombine.postParse)rr T) r/ r4 r5 rB r} rs rs r� r� r, r� r* r_ r* r* rS r+ r � s" ������r c �4 e Zd ZdZd dedef� fdd� Zdd� Z� ZS ) 2195 r� a� Converter to return the matched tokens as a list - useful for 2196 returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions. 2197 2198 The optional ``aslist`` argument when set to True will return the 2199 parsed tokens as a Python list instead of a pyparsing ParseResults. 2200 2201 Example:: 2202 2203 ident = Word(alphas) 2204 num = Word(nums) 2205 term = ident | num 2206 func = ident + Opt(delimited_list(term)) 2207 print(func.parse_string("fn a, b, 100")) 2208 # -> ['fn', 'a', 'b', '100'] 2209 2210 func = ident + Group(Opt(delimited_list(term))) 2211 print(func.parse_string("fn a, b, 100")) 2212 # -> ['fn', ['a', 'b', '100']] 2213 Fr� �aslistc � t � �|� d| _|| _d S r� )rQ r, r� � _asPythonList)r( r� r rS r* r+ r, K � 2214 zGroup.__init__c C s. | j rt�t|t�r|�� �S t|��S |gS r& )r r r r1 r- r� r( r* r* r+ r* P s ���zGroup.postParser+ � r/ r4 r5 rB r} rs r, r* r_ r* r* rS r+ r� 6 s r� c r ) 2215 r3 ar Converter to return a repetitive expression as a list, but also 2216 as a dictionary. Each element can also be referenced using the first 2217 token in the expression as its key. Useful for tabular report 2218 scraping when the first column can be used as a item key. 2219 2220 The optional ``asdict`` argument when set to True will return the 2221 parsed tokens as a Python dict instead of a pyparsing ParseResults. 2222 2223 Example:: 2224 2225 data_word = Word(alphas) 2226 label = data_word + FollowedBy(':') 2227 2228 text = "shape: SQUARE posn: upper left color: light blue texture: burlap" 2229 attr_expr = (label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join)) 2230 2231 # print attributes as plain groups 2232 print(attr_expr[1, ...].parse_string(text).dump()) 2233 2234 # instead of OneOrMore(expr), parse using Dict(Group(expr)[1, ...]) - Dict will auto-assign names 2235 result = Dict(Group(attr_expr)[1, ...]).parse_string(text) 2236 print(result.dump()) 2237 2238 # access named fields as dict entries, or output as dict 2239 print(result['shape']) 2240 print(result.as_dict()) 2241 2242 prints:: 2243 2244 ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap'] 2245 [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 2246 - color: 'light blue' 2247 - posn: 'upper left' 2248 - shape: 'SQUARE' 2249 - texture: 'burlap' 2250 SQUARE 2251 {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'} 2252 2253 See more examples at :class:`ParseResults` of accessing fields by results name. 2254 Fr� �asdictc r r� )rQ r, r� � _asPythonDict)r( r� r rS r* r+ r, � r z Dict.__init__c C s& t |�D ]w\}}t|�dkrq|d }t|t�r t|��� }t|�dkr,td|�||< qt|�dkrCt|d t�sCt|d |�||< qz|�� }W n t yW t 2255 d�}|d �w |d= t|�dksjt|t�rr|� � rrt||�||< qt|d |�||< q| j r�| j r�|�� gS |�� S | j r�|gS |S )Nr r rr ra zdcould not extract dict values from parsed results - Dict expression must contain Grouped expressions)r� r! r1 r� rs r r r r� r0 r� rG r r� �as_dict) r( r� r� r) rp �tok�ikey� dictvaluer� r* r* r+ r* � s: 2256 �� ��zDict.postParser+ r r* r* rS r+ r3 [ s )r3 c sf e Zd ZdZddeeef def� fdd� Zd� fd d 2257 � Z d� fd d � Z 2258 d d� Z defdd�Z � Z S )r� a� Converter for ignoring the results of a parsed expression. 2259 2260 Example:: 2261 2262 source = "a, b, c,d" 2263 wd = Word(alphas) 2264 wd_list1 = wd + (',' + wd)[...] 2265 print(wd_list1.parse_string(source)) 2266 2267 # often, delimiters that are useful during parsing are just in the 2268 # way afterward - use Suppress to keep them out of the parsed output 2269 wd_list2 = wd + (Suppress(',') + wd)[...] 2270 print(wd_list2.parse_string(source)) 2271 2272 # Skipped text (using '...') can be suppressed as well 2273 source = "lead in START relevant text END trailing text" 2274 start_marker = Keyword("START") 2275 end_marker = Keyword("END") 2276 find_body = Suppress(...) + start_marker + ... + end_marker 2277 print(find_body.parse_string(source) 2278 2279 prints:: 2280 2281 ['a', ',', 'b', ',', 'c', ',', 'd'] 2282 ['a', 'b', 'c', 'd'] 2283 ['START', 'relevant text ', 'END'] 2284 2285 (See also :class:`delimited_list`.) 2286 Fr� r� c s" |du r t t� �}t� �|� d S )N.)r� rg rQ r, r� rS r* r+ r, � s 2287 zSuppress.__init__rP r} c s( t | jt�rtt|��| S t� �|�S r& )r1 r� r� r� r� rQ r� r� rS r* r+ r� � � zSuppress.__add__c s( t | jt�rtt|��| S t� �|�S r& )r1 r� r� r� r� rQ r� r� rS r* r+ r� � r$ zSuppress.__sub__c C r� r& r* r( r* r* r+ r* � r+ zSuppress.postParsec C r� r& r* r� r* r* r+ r� � r+ zSuppress.suppressr+ r, )r/ r4 r5 rB r r} rs rs r, r� r� r* r� r_ r* r* rS r+ r� � s r� r� c s t � �� � fdd�}� j|_|S )as Decorator for debugging parse actions. 2288 2289 When the parse action is called, this decorator will print 2290 ``">> entering method-name(line:<current_source_line>, <parse_location>, <matched_tokens>)"``. 2291 When the parse action completes, the decorator will print 2292 ``"<<"`` followed by the returned value, or any exception that the parse action raised. 2293 2294 Example:: 2295 2296 wd = Word(alphas) 2297 2298 @trace_parse_action 2299 def remove_duplicate_chars(tokens): 2300 return ''.join(sorted(set(''.join(tokens)))) 2301 2302 wds = wd[1, ...].set_parse_action(remove_duplicate_chars) 2303 print(wds.parse_string("slkdjs sld sldd sdlf sdljf")) 2304 2305 prints:: 2306 2307 >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {})) 2308 <<leaving remove_duplicate_chars (ret: 'dfjkls') 2309 ['dfjkls'] 2310 c 2311 s� � j }| dd � \}}}t| �dkr | d jj d | }tj�d�|t||�||�� z� | � }W n tyH } z tj�d�||�� � d }~ww tj�d�||�� |S )N�����r# r �.z$>>entering {}(line: {!r}, {}, {!r}) 2312 z <<leaving {} (exception: {}) 2313 z<<leaving {} (ret: {!r}) 2314 ) r/ r! r� r �stderrr r� r� r0 )�paArgs�thisFuncr� r� r� r2 r� �r� r* r+ �z s � ��z trace_parse_action.<locals>.z)r� r/ )r� r+ r* r* r+ �trace_parse_action� s r, �empty� 2315 line_start�line_end� string_start� 2316 string_endz\[]-*.$+^?()~ ra )r� c C s |d d S r r* r� r* r* r+ r� s r� z\\0?[xX][0-9a-fA-F]+c C s t t|d �d�d��S )Nr z\0xr� )�chrr� r r� r* r* r+ r� # r: z \\0[0-7]+c C s t t|d dd � d��S )Nr r r$ )r2 r� r� r* r* r+ r� & rA z\]r3 r� �^�negate�bodyr� r� c s@ dd� � zd� � fdd�t�| �jD ��W S ty Y dS w )a Helper to easily define string ranges for use in :class:`Word` 2317 construction. Borrows syntax from regexp ``'[]'`` string range 2318 definitions:: 2319 2320 srange("[0-9]") -> "0123456789" 2321 srange("[a-z]") -> "abcdefghijklmnopqrstuvwxyz" 2322 srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_" 2323 2324 The input string must be enclosed in []'s, and the returned string 2325 is the expanded character set joined into a single string. The 2326 values enclosed in the []'s may be: 2327 2328 - a single character 2329 - an escaped character with a leading backslash (such as ``\-`` 2330 or ``\]``) 2331 - an escaped hex character with a leading ``'\x'`` 2332 (``\x21``, which is a ``'!'`` character) (``\0x##`` 2333 is also supported for backwards compatibility) 2334 - an escaped octal character with a leading ``'\0'`` 2335 (``\041``, which is a ``'!'`` character) 2336 - a range of any of the above, separated by a dash (``'a-z'``, 2337 etc.) 2338 - any combination of the above (``'aeiouy'``, 2339 ``'a-zA-Z0-9_$'``, etc.) 2340 c S s< t | t�s| S d�dd� tt| d �t| d �d �D ��S )Nrr c s r 2341 r& )r2 r� r* r* r+ r Q r z+srange.<locals>.<lambda>.<locals>.<genexpr>r r )r1 r r� r� �ord)�pr* r* r+ r� O s �.zsrange.<locals>.<lambda>rr c 3 s � | ]}� |�V qd S r& r* )r> �part�� _expandedr* r+ r T r zsrange.<locals>.<genexpr>)r� �_reBracketExprrk r5 r0 )r� r* r9 r+ �srange4 s �" �r< c s, � �fdd�}t �dt �d�j�}||_|S )a^ Helper to define a parse action by mapping a function to all 2342 elements of a :class:`ParseResults` list. If any additional args are passed, 2343 they are forwarded to the given function as additional arguments 2344 after the token, as in 2345 ``hex_integer = Word(hexnums).set_parse_action(token_map(int, 16))``, 2346 which will convert the parsed data to an integer using base 16. 2347 2348 Example (compare the last to example in :class:`ParserElement.transform_string`:: 2349 2350 hex_ints = Word(hexnums)[1, ...].set_parse_action(token_map(int, 16)) 2351 hex_ints.run_tests(''' 2352 00 11 22 aa FF 0a 0d 1a 2353 ''') 2354 2355 upperword = Word(alphas).set_parse_action(token_map(str.upper)) 2356 upperword[1, ...].run_tests(''' 2357 my kingdom for a horse 2358 ''') 2359 2360 wd = Word(alphas).set_parse_action(token_map(str.title)) 2361 wd[1, ...].set_parse_action(' '.join).run_tests(''' 2362 now is the winter of our discontent made glorious summer by this sun of york 2363 ''') 2364 2365 prints:: 2366 2367 00 11 22 aa FF 0a 0d 1a 2368 [0, 17, 34, 170, 255, 10, 13, 26] 2369 2370 my kingdom for a horse 2371 ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE'] 2372 2373 now is the winter of our discontent made glorious summer by this sun of york 2374 ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'] 2375 c s � �fdd�|D �S )Nc s g | ] 2376 }�|g� �R � �qS r* r* )r> �tokn�r� r) r* r+ r@ r� z)token_map.<locals>.pa.<locals>.<listcomp>r* r� r> r* r+ r� ~ r� ztoken_map.<locals>.par/ r� )r� r/ )r) r� r� r� r* r> r+ � token_mapY s %r? c C s8 t �� jj�� D ]\} }t|t�r|js|�| � qdS )zy 2377 Utility to simplify mass-naming of parser elements, for 2378 generating railroad diagram with named subdiagrams. 2379 N) r � _getframe�f_back�f_localsr� r1 r} r� r� )rN �varr* r* r+ �autoname_elements� s 2380 2381 ��rD 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 literalz#[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]z[\0xa1-\0xbf\0xd7\0xf7]c C s g | ] }t |t�r|�qS r* )r1 r} )r> r� r* r* r+ r@ � s 2382 2383 ��r� rU )r# r� r+ )��osr� r r r r r r r r r 2384 r �abcr r �enumr r� r� r1 r� r �collections.abcr r� �types�operatorr � functoolsr � threadingr �pathlibr �utilr r r r r r r r r] r r\ � 2385 exceptions�actionsr� r r �unicoder! �maxsizer4 rs �bytesr" r� r� � version_infor% r6 rI r` ri rl rT r� rs r{ � warnoptions�environr �sumr! r� r r� r� r� r" r rr r� r� � GeneratorTyper! r� r/ r0 r0 r1 r� r� r� �ascii_uppercase�ascii_lowercase�alphas�Latin1� 2386 identchars�identbodychars�nums�hexnumsr� r� � printabler r� � StackSummaryr� r� r� r� r� r� r} r� r` rg rg r rp r� rx r� r� r� r� r� r� r� r� r� r� r r r r r rh r r r r� r� r� r� r� r? r� r� r� r� r� r� r� r� r� r� r� r� rB r r r� r3 r� r, r� r- r. r/ r0 r1 r � _escapedPunc�_escapedHexChar�_escapedOctChar� _singleChar� 2387 _charRanger� r; r< r? rD �dbl_quoted_string�sgl_quoted_stringr �unicode_string� 2388 alphas8bit�punc8bitr� �valuesr� �tokenMap�conditionAsParseAction�nullDebugAction�sglQuotedString�dblQuotedString� quotedString� unicodeString� lineStart�lineEnd� stringStart� stringEnd�traceParseActionr* r* r* r+ �<module> s$ 2389 0 , 2390 ! 2391 �� 2392 ��� 2393 �� 2394 ��� 2395 =���� 2396 � ���� 2397 ������� 2398 ������ 2399 � *) -vY q 2400 EPM / " o (]@!$Q*+N !I w 2401 9%W7 0 ���� ����% 2402 . 2403 2404 �� 2405 �� 2406 2407 ����