+
    TBi4                       ^ RI Ht ^ RIHtHtHt ^RIHt ^RIH	t	H
t
 ^RIHt ]]. ]3,          ]].]3,          ]]].]3,          ]]]].]3,          3,          t ! R R4      tR R	 ltR
 R ltR R ltR R lt]! 4       ]n        RR R llt]
! R]4      t]
! R]4      t]
! R]4      t]
! R]4      t]
! R]4      tR# )    )annotations)UnionCallableAny)ParseException)colreplaced_by_pep8)ParseResultsc                  8    ] tR t^tRtR R ltR R ltR tRtR# )	OnlyOncez|
Wrapper for parse actions, to ensure they are only called once.
Note: parse action signature must include all 3 arguments.
c                    V ^8  d   QhRRRR/# )   method_callz'Callable[[str, int, ParseResults], Any]returnNone )formats   "6/usr/lib/python3.14/site-packages/pyparsing/actions.py__annotate__OnlyOnce.__annotate__   s      $K PT     c                	:    ^RI Hp V! V4      V n        RV n        R# )   )_trim_arityFN)corer   callablecalled)selfr   r   s   && r   __init__OnlyOnce.__init__   s    %#K0r   c               (    V ^8  d   QhRRRRRRRR/# )r   sstrlinttr
   r   r   )r   s   "r   r   r      s.     U U# U# U, U< Ur   c                	t    V P                   '       g   V P                  WV4      pR V n         V# \        WR4      h)Tz.OnlyOnce obj called multiple times w/out reset)r   r   r   )r   r"   r$   r&   resultss   &&&& r   __call__OnlyOnce.__call__   s5    {{{mmA!,GDKNQ#STTr   c                    RV n         R# )z;
Allow the associated parse action to be called once more.
FN)r   )r   s   &r   resetOnlyOnce.reset&   s    
 r   )r   r   N)	__name__
__module____qualname____firstlineno____doc__r   r)   r,   __static_attributes__r   r   r   r   r      s    
Ur   r   c                    V ^8  d   QhRRRR/# )r   nr%   r   ParseActionr   )r   s   "r   r   r   .   s     
 
 
 
r   c                   a  R V 3R llpV# )zh
Helper method for defining parse actions that require matching at
a specific column in the input text.
c               (    V ^8  d   QhRRRRRRRR/# )	r   strgr#   locnr%   toksr
   r   r   r   )r   s   "r   r   'match_only_at_col.<locals>.__annotate__4   s.     Q Q QC Q| Q Qr   c                F   < \        W4      S8w  d   \        WR S 24      hR# )zmatched token not at column N)r   r   )r9   r:   r;   r5   s   &&&r   
verify_col%match_only_at_col.<locals>.verify_col4   s)    t?a /KA3-OPP  r   r   )r5   r>   s   f r   match_only_at_colr@   .   s    Q Q r   c                    V ^8  d   QhRRRR/# )r   repl_strr   r   r6   r   )r   s   "r   r   r   ;   s     & &3 &; &r   c                   a  V 3R l# )a  
Helper method for common parse actions that simply return
a literal value.  Especially useful when used with
:meth:`~ParserElement.transform_string`.

Example:

.. doctest::

   >>> num = Word(nums).set_parse_action(lambda toks: int(toks[0]))
   >>> na = one_of("N/A NA").set_parse_action(replace_with(math.nan))
   >>> term = na | num

   >>> term[1, ...].parse_string("324 234 N/A 234")
   ParseResults([324, 234, nan, 234], {})
c                
   < S.# )Nr   )r"   r$   r&   rB   s   &&&r   <lambda>replace_with.<locals>.<lambda>L   s    H:r   r   )rB   s   fr   replace_withrG   ;   s    " &%r   c               (    V ^8  d   QhRRRRRRRR/# )	r   r"   r#   r$   r%   r&   r
   r   r   r   )r   s   "r   r   r   O   s(      S S \ c r   c                    V^ ,          ^R # )a  
Helper parse action for removing quotation marks from parsed
quoted strings, that use a single character for quoting. For parsing
strings that may have multiple characters, use the :class:`QuotedString`
class.

Example:

.. doctest::

   >>> # by default, quotation marks are included in parsed results
   >>> quoted_string.parse_string("'Now is the Winter of our Discontent'")
   ParseResults(["'Now is the Winter of our Discontent'"], {})

   >>> # use remove_quotes to strip quotation marks from parsed results
   >>> dequoted = quoted_string().set_parse_action(remove_quotes)
   >>> dequoted.parse_string("'Now is the Winter of our Discontent'")
   ParseResults(['Now is the Winter of our Discontent'], {})
r   )r"   r$   r&   s   &&&r   remove_quotesrK   O   s    ( Q4":r   c                    V ^8  d   QhRRRR/# )r   argsztuple[str, str]r   r6   r   )r   s   "r   r   r   f   s     Z Z/ Z; Zr   c                    a . oV '       d   SP                  V 4       MSP                  VP                  4       4       R V3R llpV# )a#  
Helper to create a validating parse action to be used with start
tags created with :class:`make_xml_tags` or
:class:`make_html_tags`. Use ``with_attribute`` to qualify
a starting tag with a required attribute value, to avoid false
matches on common tags such as ``<TD>`` or ``<DIV>``.

Call ``with_attribute`` with a series of attribute names and
values. Specify the list of filter attributes names and values as:

- keyword arguments, as in ``(align="right")``, or
- as an explicit dict with ``**`` operator, when an attribute
  name is also a Python reserved word, as in ``**{"class":"Customer", "align":"right"}``
- a list of name-value tuples, as in ``(("ns1:class", "Customer"), ("ns2:align", "right"))``

For attribute names with a namespace prefix, you must use the second
form.  Attribute names are matched insensitive to upper/lower case.

If just testing for ``class`` (with or without a namespace), use
:class:`with_class`.

To verify that the attribute exists, but without specifying a value,
pass ``with_attribute.ANY_VALUE`` as the value.

The next two examples use the following input data and tag parsers:

.. testcode::

   html = '''
       <div>
       Some text
       <div type="grid">1 4 0 1 0</div>
       <div type="graph">1,3 2,3 1,1</div>
       <div>this has no type</div>
       </div>
   '''
   div,div_end = make_html_tags("div")

Only match div tag having a type attribute with value "grid":

.. testcode::

   div_grid = div().set_parse_action(with_attribute(type="grid"))
   grid_expr = div_grid + SkipTo(div | div_end)("body")
   for grid_header in grid_expr.search_string(html):
       print(grid_header.body)

prints:

.. testoutput::

   1 4 0 1 0

Construct a match with any div tag having a type attribute,
regardless of the value:

.. testcode::

   div_any_type = div().set_parse_action(
       with_attribute(type=with_attribute.ANY_VALUE)
   )
   div_expr = div_any_type + SkipTo(div | div_end)("body")
   for div_header in div_expr.search_string(html):
       print(div_header.body)

prints:

.. testoutput::

   1 4 0 1 0
   1,3 2,3 1,1
c               (    V ^8  d   QhRRRRRRRR/# )	r   r"   r#   r$   r%   tokensr
   r   r   r   )r   s   "r   r   $with_attribute.<locals>.__annotate__   s(     	 	c 	c 	< 	D 	r   c                   < S Fa  w  r4W29  d   \        WR V,           4      hV\        P                  8w  g   K5  W#,          V8w  g   KD  \        V VRV: RW#,          : RV: 24      h	  R# )zno matching attribute z
attribute z has value z
, must be N)r   with_attribute	ANY_VALUE)r"   r$   rP   attrName	attrValue
attrs_lists   &&&  r   pawith_attribute.<locals>.pa   sp    #-H%$Q+Ch+NOON4449IY9V$ K8H7K:V_Ubc 	 $.r   )extenditems)rM   	attr_dictrX   rW   s   *, @r   rS   rS   f   sB    R )+J$)//+,	 	 Ir   c               $    V ^8  d   QhRRRRRR/# )r   	classnamer#   	namespacer   r6   r   )r   s   "r   r   r      s!     74 74# 74# 74{ 74r   c                8    V'       d   V R2MRp\        R/ W /B # )ay  
Simplified version of :meth:`with_attribute` when
matching on a div class - made difficult because ``class`` is
a reserved word in Python.

Using similar input data to the :meth:`with_attribute` examples:

.. testcode::

   html = '''
       <div>
       Some text
       <div class="grid">1 4 0 1 0</div>
       <div class="graph">1,3 2,3 1,1</div>
       <div>this &lt;div&gt; has no class</div>
       </div>
   '''
   div,div_end = make_html_tags("div")

Only match div tag having the "grid" class:

.. testcode::

   div_grid = div().set_parse_action(with_class("grid"))
   grid_expr = div_grid + SkipTo(div | div_end)("body")
   for grid_header in grid_expr.search_string(html):
       print(grid_header.body)

prints:

.. testoutput::

   1 4 0 1 0

Construct a match with any div tag having a class attribute,
regardless of the value:

.. testcode::

   div_any_type = div().set_parse_action(
       with_class(withAttribute.ANY_VALUE)
   )
   div_expr = div_any_type + SkipTo(div | div_end)("body")
   for div_header in div_expr.search_string(html):
       print(div_header.body)

prints:

.. testoutput::

   1 4 0 1 0
   1,3 2,3 1,1
z:classclassr   )rS   )r^   r_   	classattrs   && r   
with_classrc      s&    l )29+V$wI3Y233r   replaceWithremoveQuoteswithAttribute	withClassmatchOnlyAtColN) )
__future__r   typingr   r   r   
exceptionsr   utilr   r	   r(   r
   r%   r#   r6   r   r@   rG   rK   rS   objectrT   rc   rd   re   rf   rg   rh   r   r   r   <module>ro      s    " ' ' & ' ! RWl^S !c< #%&c3%s*+- 6
&(.Zz "8 74x }l;> .A[*5	!"24EFr   