
    ei*              	         d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZ ddl	m
Z ddlmZmZmZmZmZmZ  G d dej&                  ej(                  ej*                  ej,                  ej.                        Z eej2                        Z ej6                  d	ez   d
z         Z G d de      Z G d de      Z G d de      Z  G d de       Z! G d de      Z"y)    )annotationsN)cached_property   )pyparsing_unicode)_collapse_string_to_rangescoldeprecate_argumentlinelinenoreplaced_by_pep8c                      e Zd Zy)_ExceptionWordUnicodeSetN)__name__
__module____qualname__     V/var/www/html/glpi_dashboard/venv/lib/python3.12/site-packages/pyparsing/exceptions.pyr   r      s     	r   r   z([z
]{1,16})|.c                  d   e Zd ZU dZded<   ded<   ded<   ded<   d	ed
<   dZ	 	 	 d	 	 	 	 	 	 	 ddZed d!d       Ze	d"d       Z
ed#d       Zed$d       Zed$d       Zed$d       Zed#d       Zed        Zej&                  d        Zd Zd#dZd#dZd Z	 d%	 	 	 d&dZd d'dZ ede      Zy)(ParseBaseExceptionz7base exception class for all parsing runtime exceptionsintlocstrmsgpstrz
typing.Anyparser_elementz%tuple[str, int, typing.Optional[str]]argsr   r   r   r   r   Nc                \    ||d}}|| _         || _        || _        || _        |||f| _        y )N r   )selfr   r   r   elems        r   __init__zParseBaseException.__init__3   s=     ;bC	"3$	r   c                V   ddl }ddlm} |t        j                         }g }t        | t              r<|j                  | j                         |j                  dd| j                   d       |j                  t        |       j                   d|         |dk  s| j                  d	j                  |      S |j                  | j                  |
      }t               }|| d D ]/  }|d   }|j                   j#                  dd      }	t        |	|      r|j$                  j&                  j)                  d      sWt+        |	      |v re|j-                  t+        |	             t        |	      }
|j                  |
j.                   d|
j                   d|	        no|	6t        |	      }
|j                  |
j.                   d|
j                          n7|j$                  }|j&                  dv r|j                  |j&                         |dz  }|r0 n d	j                  |      S )a  
        Method to take an exception and translate the Python internal traceback into a list
        of the pyparsing expressions that caused the exception to be raised.

        Parameters:

        - exc - exception raised during parsing (need not be a ParseException, in support
          of Python exceptions that might be raised in a parse action)
        - depth (default=16) - number of levels back in the stack trace to list expression
          and function names; if None, the full stack trace names will be listed; if 0, only
          the failing input line, marker, and exception string will be shown

        Returns a multi-line string listing the ParserElements and/or function names in the
        exception's stack trace.
        r   Nr   )ParserElement^>r    : 
)contextr!   )	parseImpl_parseNoCache.z - )wrapperz<module>)inspectcorer%   sysgetrecursionlimit
isinstancer   appendr
   columntyper   __traceback__joingetinnerframessetf_localsgetf_codeco_name
startswithidaddr   )excdepthr/   r%   retcallersseenfffrmf_self	self_typecodes               r   explain_exceptionz$ParseBaseException.explain_exceptionC   s   " 	'=))+Ec-.JJsxx JJ#a

|0^,.

d3i(()C512A:**299S>!(():):E(J5&'" 	BQ%C\\%%fd3F&-0zz))445STf:%F$ L	

i2231Y5G5G4HF8TU# L	

i2231Y5G5G4HIJ zz<<#::

4<<(QJE7	: yy~r   c                h     | |j                   |j                  |j                  |j                        S )z
        internal factory method to simplify creating one type of ParseException
        from another - avoids having __init__ signature conflicts among subclasses
        )r   r   r   r   )clspes     r   _from_exceptionz"ParseBaseException._from_exception   s'     277BFFBFFB,=,=>>r   c                B    t        | j                  | j                        S )zG
        Return the line of text where the exception occurred.
        )r
   r   r   r!   s    r   r
   zParseBaseException.line   s    
 DHHdii((r   c                B    t        | j                  | j                        S )zV
        Return the 1-based line number of text where the exception occurred.
        )r   r   r   rR   s    r   r   zParseBaseException.lineno   s    
 dhh		**r   c                B    t        | j                  | j                        S z]
        Return the 1-based column on the line of text where the exception occurred.
        r   r   r   rR   s    r   r   zParseBaseException.col       
 488TYY''r   c                B    t        | j                  | j                        S rU   rV   rR   s    r   r5   zParseBaseException.column   rW   r   c                `   | j                   sy| j                  t        | j                         k\  ryt        j	                  | j                   | j                        }||j                  d      }n&| j                   | j                  | j                  dz    }t        |      j                  dd      S )Nr    zend of textr   r   z\\\)r   r   len_exception_word_extractormatchgroupreprreplace)r!   found_match
found_texts      r   foundzParseBaseException.found   s    yy88s499~%  055diiJ"$**1-J488dhhl;JJ''t44r   c                R    t        j                  dt        d       | j                  S Nz/parserElement is deprecated, use parser_element   )
stacklevelwarningswarnDeprecationWarningr   rR   s    r   parserElementz ParseBaseException.parserElement   s%    =	

 """r   c                J    t        j                  dt        d       || _        y re   rh   )r!   r"   s     r   rl   z ParseBaseException.parserElement   s!    =	

 #r   c                ,    t        j                   |       S N)copyrR   s    r   rp   zParseBaseException.copy   s    yyr   c           	         | j                   rd| j                    nd}| j                   | d| j                   d| j                   d| j                   d	S )z
        Output the formatted exception message.
        Can be overridden to customize the message formatting or contents.

        .. versionadded:: 3.2.0
        z, found r    z  (at char z	), (line:z, col:))rc   r   r   r   r5   )r!   found_phrases     r   formatted_messagez$ParseBaseException.formatted_message   sU     37**$**."((L>TXXJi}TZ[_[f[fZgghiir   c           	         	 | j                         S # t        $ rH}t        |       j                   d| j                   dt        |      j                   d| dcY d}~S d}~ww xY w)zl
        .. versionchanged:: 3.2.0
           Now uses :meth:`formatted_message` to format message.
        r(   z (z while formatting message)N)rt   	Exceptionr6   r   r   )r!   exs     r   __str__zParseBaseException.__str__   sf    
	))++ 	:&&'r$((T"X&&'r"-GI	s    	A#=AA#A#c                    t        |       S ro   )r   rR   s    r   __repr__zParseBaseException.__repr__   s    4yr   c                    t        |dd      }||n|}| j                  }| j                  dz
  }|r|d|  | ||d  }|j                         S )z
        Extracts the exception line from the input string, and marks
        the location of the exception with a special symbol.
        markerStringz>!<Nr   )r	   r
   r5   strip)r!   marker_stringkwargsr|   line_strline_columns         r   mark_input_linez"ParseBaseException.mark_input_line   sf     /v~uM(5(A}|99kkAo"<K01,@V?WXH~~r   c                &    | j                  | |      S )a  
        Method to translate the Python internal traceback into a list
        of the pyparsing expressions that caused the exception to be raised.

        Parameters:

        - depth (default=16) - number of levels back in the stack trace to list expression
          and function names; if None, the full stack trace names will be listed; if 0, only
          the failing input line, marker, and exception string will be shown

        Returns a multi-line string listing the ParserElements and/or function names in the
        exception's stack trace.

        Example:

        .. testcode::

            # an expression to parse 3 integers
            expr = pp.Word(pp.nums) * 3
            try:
                # a failing parse - the third integer is prefixed with "A"
                expr.parse_string("123 456 A789")
            except pp.ParseException as pe:
                print(pe.explain(depth=0))

        prints:

        .. testoutput::

            123 456 A789
                    ^
            ParseException: Expected W:(0-9), found 'A789'  (at char 8), (line:1, col:9)

        Note: the diagnostic output will include string representations of the expressions
        that failed to parse. These representations will be more helpful if you use `set_name` to
        give identifiable names to your expressions. Otherwise they will use the default string
        forms, which may be cryptic to read.

        Note: pyparsing's default truncation of exception tracebacks may also truncate the
        stack of expressions that are displayed in the ``explain`` output. To get the full listing
        of parser expressions, you may have to set ``ParserElement.verbose_stacktrace = True``
        )rL   )r!   rC   s     r   explainzParseBaseException.explain   s    V %%dE22r   markInputline)r   NN)r   r   r   r   r   typing.Optional[str]returnNone)   )rB   rv   rC   r   r   r   )r   r   r   r   )r   r   ro   )r~   r   r   r   )rC   r   r   r   )r   r   r   __doc____annotations__	__slots__r#   staticmethodrL   classmethodrP   r   r
   r   r   r5   rc   propertyrl   setterrp   rt   rx   rz   r   r   r   r   r   r   r   r   r       s[   A	H	H
I
//I $(%% % "	% 
%  = =~ ? ? ) ) + + ( ( ( ( 5 5" # # # #j 59 1 	  +3^ %_oFMr   r   c                      e Zd ZdZy)ParseExceptiona  
    Exception thrown when a parse expression doesn't match the input string

    Example:

    .. testcode::

        integer = Word(nums).set_name("integer")
        try:
            integer.parse_string("ABC")
        except ParseException as pe:
            print(pe, f"column: {pe.column}")

    prints:

    .. testoutput::

       Expected integer, found 'ABC'  (at char 0), (line:1, col:1) column: 1

    Nr   r   r   r   r   r   r   r   r   +  s    r   r   c                      e Zd ZdZy)ParseFatalExceptionzu
    User-throwable exception thrown when inconsistent parse content
    is found; stops all parsing immediately
    Nr   r   r   r   r   r   B  s    r   r   c                      e Zd ZdZy)ParseSyntaxExceptionz
    Just like :class:`ParseFatalException`, but thrown internally
    when an :class:`ErrorStop<And._ErrorStop>` ('-' operator) indicates
    that parsing is to stop immediately because an unbacktrackable
    syntax error has been found.
    Nr   r   r   r   r   r   I  s    r   r   c                       e Zd ZdZddZddZy)RecursiveGrammarExceptionaL  
    .. deprecated:: 3.0.0
       Only used by the deprecated :meth:`ParserElement.validate`.

    Exception thrown by :class:`ParserElement.validate` if the
    grammar could be left-recursive; parser may need to enable
    left recursion using :class:`ParserElement.enable_left_recursion<ParserElement.enable_left_recursion>`
    c                    || _         y ro   parseElementTrace)r!   parseElementLists     r   r#   z"RecursiveGrammarException.__init__\  s
    !1r   c                     d| j                    S )NzRecursiveGrammarException: r   rR   s    r   rx   z!RecursiveGrammarException.__str___  s    ,T-C-C,DEEr   N)r   r   r   )r   r   r   r   r#   rx   r   r   r   r   r   R  s    2Fr   r   )#
__future__r   rp   rer1   typingri   	functoolsr   unicoder   ppuutilr   r   r	   r
   r   r   Latin1LatinALatinBGreekCyrillicr   	alphanums_extract_alphanumscompiler\   rv   r   r   r   r   r   r   r   r   <module>r      s    "  	 
   % - 	JJ

CJJ		3<<	 00H0R0RS &BJJt.@'@<'OP GG GGV' ., . F	 Fr   