HEX

File: //proc/1233/cwd/lib/python3/dist-packages/__pycache__/docopt.cpython-310.pyc
o

�ўS�M�@svdZddlZddlZdgZdZGdd�de�ZGdd�de�ZGd	d
�d
e	�Z
Gdd�de
�ZGd
d�de
�ZGdd�de�Z
Gdd�de
�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd �d e�Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd<d.d/�Zd0d1�Zd2d3�Zd4d5�Z d6d7�Z!Gd8d9�d9e"�Z#d=d;d�Z$dS)>aPythonic command-line interface parser that will make you smile.

 * http://docopt.org
 * Repository and issue-tracker: https://github.com/docopt/docopt
 * Licensed under terms of MIT license (see LICENSE-MIT)
 * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com

�N�docoptz0.6.2c@�eZdZdZdS)�DocoptLanguageErrorz4Error in construction of usage-message by developer.N��__name__�
__module__�__qualname__�__doc__�r
r
�(/usr/lib/python3/dist-packages/docopt.pyr�rc@seZdZdZdZddd�ZdS)�
DocoptExitz;Exit in case user invoked program with incorrect arguments.�cCst�||d|j���dS)N�
)�
SystemExit�__init__�usage�strip)�self�messager
r
rrszDocoptExit.__init__N)r)rrrr	rrr
r
r
rr
sr
c@sBeZdZdd�Zdd�Zdd�Zddd	�Zd
d�Zedd
��Z	dS)�PatterncCst|�t|�kS�N��repr)r�otherr
r
r�__eq__"szPattern.__eq__cCstt|��Sr)�hashr�rr
r
r�__hash__%szPattern.__hash__cCs|��|��|Sr)�fix_identities�fix_repeating_argumentsrr
r
r�fix(szPattern.fixNcCsxt|d�s|S|durtt|����n|}t|j�D]\}}t|d�s4||vs)J�||�|�|j|<q|�|�qdS)z>Make pattern-tree tips point to same object if they are equal.�childrenN)�hasattr�list�set�flat�	enumerater"�indexr)r�uniq�i�cr
r
rr-s

�zPattern.fix_identitiescs�dd�|jjD�}|D]G��fdd��D�D];}t|�tus't|�tur=|jr=|jdur0g|_n
t|j�tur=|j��|_t|�t	usNt|�turQ|jdkrQd|_qq|S)z5Fix elements that should accumulate/increment values.cSsg|]}t|j��qSr
�r$r"��.0r+r
r
r�
<listcomp>;�z3Pattern.fix_repeating_arguments.<locals>.<listcomp>csg|]}��|�dkr|�qS)�)�countr-��caser
rr/=sNr)
�eitherr"�type�Argument�Option�argcount�valuer$�split�Command)rr5�er
r3rr 9s
"��zPattern.fix_repeating_argumentsc
Cs�g}|gg}|r�|�d�}dd�|D�}t|vr8dd�|D�d}|�|�|��|jD]
}|�|g|�q,n�t|vrXdd�|D�d}|�|�|��|�t|j�|�ngt|vrxdd�|D�d}|�|�|��|�t|j�|�nGt|vr�dd�|D�d}|�|�|��|�t|j�|�n't	|vr�dd�|D�d}	|�|�|	��|�t|	j�d	|�n|�|�|std
d�|D��S)zATransform pattern into an equivalent, with only top-level Either.rcSsg|]}t|��qSr
�r6r-r
r
rr/P�z"Pattern.either.<locals>.<listcomp>cS�g|]
}t|�tur|�qSr
)r6�Eitherr-r
r
rr/R�cSr@r
)r6�Requiredr-r
r
rr/WrBcSr@r
)r6�Optionalr-r
r
rr/[rBcSr@r
)r6�
AnyOptionsr-r
r
rr/_rBcSr@r
)r6�	OneOrMorer-r
r
rr/crB�cSsg|]}t|��qSr
)rC)r.r=r
r
rr/hr?)
�poprAr(r"�appendrCr$rDrErF)
r�ret�groupsr"�typesr5r+�required�optional�	oneormorer
r
rr5Gs<

�
�zPattern.eitherr)
rrrrrr!rr �propertyr5r
r
r
rr s
rc@s0eZdZd
dd�Zdd�Zdd�Zd
dd	�ZdS)�ChildPatternNcC�||_||_dSr��namer:�rrTr:r
r
rrm�
zChildPattern.__init__cCsd|jj|j|jfS)Nz
%s(%r, %r))�	__class__rrTr:rr
r
r�__repr__q�zChildPattern.__repr__cGs|rt|�|vr|gSgSrr>�rrLr
r
rr&tszChildPattern.flatcs�|durgn|}��|�\}}|durd||fS|d|�||dd�}�fdd�|D�}t�j�ttfvrkt�j�turBd}nt|j�turM|jgn|j}|s]||_d|||gfS|dj|7_d||fSd|||gfS)NFr1csg|]
}|j�jkr|�qSr
)rT�r.�arr
rr/}rBz&ChildPattern.match.<locals>.<listcomp>Tr)�single_matchr6r:�intr$�str)r�left�	collected�pos�match�left_�	same_name�	incrementr
rrrcws$
�
zChildPattern.matchr)rrrrrXr&rcr
r
r
rrQks

rQc@�$eZdZdd�Zdd�Zdd�ZdS)�
ParentPatterncGst|�|_dSrr,)rr"r
r
rr�szParentPattern.__init__cCs"d|jjd�dd�|jD��fS)Nz%s(%s)�, css�|]}t|�VqdSrrr[r
r
r�	<genexpr>���z)ParentPattern.__repr__.<locals>.<genexpr>)rWr�joinr"rr
r
rrX�s�zParentPattern.__repr__cs,t|��vr	|gSt�fdd�|jD�g�S)Ncsg|]}|j���qSr
)r&r-�rLr
rr/�r0z&ParentPattern.flat.<locals>.<listcomp>)r6�sumr"rZr
rmrr&�szParentPattern.flatN)rrrrrXr&r
r
r
rrh�srhc@s eZdZdd�Zedd��ZdS)r7cCs8t|�D]\}}t|�tur|t|j|j�fSqdS�N�NN)r'r6r7rTr:�rr`�n�pr
r
rr]�s
�zArgument.single_matchcCs:t�d|�d}tjd|tjd�}|||r|d�Sd�S)Nz(<\S*?>)r�\[default: (.*)\]��flags)�re�findall�I)�class_�sourcerTr:r
r
r�parse�szArgument.parseN)rrrr]�classmethodr|r
r
r
rr7�sr7c@seZdZddd�Zdd�ZdS)r<FcCrRrrSrUr
r
rr�rVzCommand.__init__cCsHt|�D]\}}t|�tur!|j|jkr|t|jd�fSdSqdS)NTrp)r'r6r7r:rTr<rqr
r
rr]�s�zCommand.single_matchN�F)rrrrr]r
r
r
rr<�s
r<c@s>eZdZddd�Zedd��Zdd	�Zed
d��Zdd
�Z	dS)r8NrFcCsH|dvsJ�|||_|_|||_|_|dur|rd|_dS||_dS)N)rr1F��short�longr9r:)rr�r�r9r:r
r
rr�s zOption.__init__cCs�d\}}}}|���d�\}}}|�dd��dd�}|��D]}	|	�d�r(|	}q|	�d�r0|	}qd}q|rFtjd	|tjd
�}
|
rD|
dnd}|||||�S)N�NNrFz  �,� �=�--�-r1rtrur)r�	partition�replacer;�
startswithrwrxry)rz�option_descriptionr�r�r9r:�options�_�description�s�matchedr
r
rr|�s

zOption.parsecCs.t|�D]\}}|j|jkr||fSqdSro)r'rTrqr
r
rr]�s
�zOption.single_matchcCs|jp|jSr)r�r�rr
r
rrT�szOption.namecCsd|j|j|j|jfS)NzOption(%r, %r, %r, %r)rrr
r
rrX�s
�zOption.__repr__r�)
rrrrr}r|r]rPrTrXr
r
r
rr8�s


r8c@�eZdZddd�ZdS)rCNcCsR|durgn|}|}|}|jD]}|�||�\}}}|s#d||fSqd||fS)NFT�r"rc)rr`ra�lr+rsr�r
r
rrc�s
�
zRequired.matchr�rrrrcr
r
r
rrC��rCc@r�)rDNcCs8|durgn|}|jD]}|�||�\}}}qd||fS)NTr�)rr`rars�mr
r
rrc�s

zOptional.matchrr�r
r
r
rrD�r�rDc@r)rEz*Marker/placeholder for [options] shortcut.Nrr
r
r
rrE�rrEc@r�)rFNcCs�t|j�dks	J�|durgn|}|}|}d}d}d}|r:|jd�||�\}}}||r.dnd7}||kr6n|}|s|dkrCd||fSd||fS)Nr1TrF)�lenr"rc)rr`rar�r+�l_r��timesr
r
rrc�s"�

zOneOrMore.matchrr�r
r
r
rrF�r�rFc@r�)rANcCsb|durgn|}g}|jD]}|�||�\}}}}|r!|�|�q
|r,t|dd�d�Sd||fS)NcSst|d�S)Nr1�r�)�outcomer
r
r�<lambda>szEither.match.<locals>.<lambda>)�keyF)r"rcrI�min)rr`ra�outcomesrsr�r�r�r
r
rrcs

�
zEither.matchrr�r
r
r
rrAr�rAc@rg)�TokenStreamcCs$|t|d�r
|��n|7}||_dS)Nr;)r#r;�error)rr{r�r
r
rr#s
zTokenStream.__init__cCst|�r	|�d�SdS�Nr)r�rHrr
r
r�move'rYzTokenStream.movecCst|�r|dSdSr�r�rr
r
r�current*szTokenStream.currentN)rrrrr�r�r
r
r
rr�!sr�cs�|���d�\�}}��d�sJ�||krdkrnndn|}�fdd�|D�}|jtur<|gkr<�fdd�|D�}t|�dkrS|�d	�d
�dd�|D��f��t|�dkr|dkr_dnd
}td�|�}|�|�|jtur|td�||ry|nd�}|gSt|d
j	|d
j
|d
j|d
j�}|jd
kr�|dur�|�d|j
��n|dur�|�
�dur�|�d|j
��|��}|jtur�|dur�|nd|_|gS)z-long ::= '--' chars [ ( ' ' | '=' ) chars ] ;r�r�rNc�g|]	}|j�kr|�qSr
�r��r.�or�r
rr/3�zparse_long.<locals>.<listcomp>cs"g|]
}|jr|j���r|�qSr
)r�r�r�r�r
rr/5s"r1z%s is not a unique prefix: %s?ricss�|]}|jVqdSrr�r�r
r
rrj8s�zparse_long.<locals>.<genexpr>rTz%s must not have an argument�%s requires argument)r�r�r�r�r
r�rlr8rIr�r�r9r:r�)�tokensr��eqr:�similarr9r�r
r�r�
parse_long.s> �

��
�
r�csT|��}|�d�r|�d�rJ�|�d�}g}|dkr�d|d|dd��}�fdd�|D�}t|�dkrB|�d	�t|�f��t|�dkr`t�dd�}|�|�|jtur_t�ddd
�}n?t�|dj|dj	|dj
�}d}|j	dkr�|dkr�|��dur�|�d���|��}n|}d}|jtur�|dur�|nd
|_
|�|�|dks|S)z-shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;r�r�rrr1Ncr�r
�r�r�r�r
rr/Wr�z parse_shorts.<locals>.<listcomp>z$%s is specified ambiguously %d timesTr�)r�r��lstripr�r�r8rIr
r�r9r:r�)r�r��tokenr`�parsedr�r�r:r
r�r�parse_shortsOsB

�

��



�r�cCsFtt�dd|�t�}t||�}|��dur|�dd�|���t|�S)Nz([\[\]\(\)\|]|\.\.\.)z \1 zunexpected ending: %rr�)	r�rw�subr�
parse_exprr�r�rlrC)r{r�r��resultr
r
r�
parse_patternrs�
r�cCs�t||�}|��dkr
|St|�dkrt|�gn|}|��dkr>|��t||�}|t|�dkr5t|�gn|7}|��dks t|�dkrIt|�gS|S)zexpr ::= seq ( '|' seq )* ;�|r1)�	parse_seqr�r�rCr�rA)r�r��seqr�r
r
rr�{s

�r�cCsPg}|��dvr&t||�}|��dkrt|�g}|��||7}|��dvs|S)zseq ::= ( atom [ '...' ] )* ;)N�]�)r�z...)r��
parse_atomrFr�)r�r�r��atomr
r
rr��s

�r�cCs�|��}g}|dvr2|��dtgdtgd�|\}}|t||��}|��|kr/|�d|��|gS|dkr>|��t�gS|�d�rL|dkrLt||�S|�d�rZ|d	vrZt	||�S|�d
�rd|�
d�sh|��rot|���gSt
|���gS)ziatom ::= '(' expr ')' | '[' expr ']' | 'options'
             | long | shorts | argument | command ;
    z([r�r�)�(�[zunmatched '%s'r�r�r�)r�r��<�>)r�r�rCrDr�r�rEr�r�r��endswith�isupperr7r<)r�r�r�r��matching�patternr
r
rr��s&

r�FcCs�g}|��durV|��dkr|dd�|D�S|���d�r&|t||�7}n*|���d�r;|��dkr;|t||�7}n|rF|dd�|D�S|�td|����|��dus|S)z�Parse command-line argument vector.

    If options_first:
        argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
    else:
        argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;

    Nr�cS�g|]}td|��qSr�r7�r.�vr
r
rr/�r0zparse_argv.<locals>.<listcomp>r�cSr�rr�r�r
r
rr/�r0)r�r�r�r�rIr7r�)r�r��
options_firstr�r
r
r�
parse_argv�s	�r�cCsNt�d|�dd�}dd�t|ddd�|ddd��D�}dd�|D�}|S)Nz
 *(<\S+?>|-\S+?)r1cSsg|]\}}||�qSr
r
)r.�s1�s2r
r
rr/�sz"parse_defaults.<locals>.<listcomp>rGcSs g|]}|�d�rt�|��qS)r�)r�r8r|�r.r�r
r
rr/�s )rwr;�zip)�docr;r�r
r
r�parse_defaults�s(r�cCsVt�d|�}t|�dkrtd��t|�dkrtd��t�dd�|dd���d��S)	Nz([Uu][Ss][Aa][Gg][Ee]:)�z&"usage:" (case-insensitive) not found.z*More than one "usage:" (case-insensitive).z\n\s*\nrr1r)rwr;r�rrlr)r��usage_splitr
r
r�printable_usage�s"r�cs8|��dd��dd��fdd��dd�D��dS)Nr1z( r�c3s$�|]
}|�dkrdn|VqdS)rz) | (Nr
r���pur
rrj�s�"zformal_usage.<locals>.<genexpr>z ))r;rl)r�r
r�r�formal_usage�s(r�cCs^|rtdd�|D��rt|�d��t��|r+tdd�|D��r-t|�t��dSdSdS)Ncss �|]}|jdvo|jVqdS))z-hz--helpNrSr�r
r
rrj���zextras.<locals>.<genexpr>rcss �|]}|jdko|jVqdS)z	--versionNrSr�r
r
rrj�r�)�any�printr�sys�exit)�help�versionr�r�r
r
r�extras�s�r�c@seZdZdd�ZdS)�DictcCs dd�dd�t|���D��S)Nz{%s}z,
 css�|]}d|VqdS)z%r: %rNr
)r.r*r
r
rrj�rkz Dict.__repr__.<locals>.<genexpr>)rl�sorted�itemsrr
r
rrX�s z
Dict.__repr__N)rrrrXr
r
r
rr��sr�Tc
Cs�|durtjdd�}t|�t_t|�}tttj�|�}tt	|t�t
|�|�}t|�t
��}|�t�D]}t|�}	t
t|	�|�|_q3t||||�|���|�\}
}}|
rg|gkrgtdd�|��|D��St��)a�Parse `argv` based on command-line interface described in `doc`.

    `docopt` creates your command-line interface based on its
    description that you pass as `doc`. Such description can contain
    --options, <positional-argument>, commands, which could be
    [optional], (required), (mutually | exclusive) or repeated...

    Parameters
    ----------
    doc : str
        Description of your command-line interface.
    argv : list of str, optional
        Argument vector to be parsed. sys.argv[1:] is used if not
        provided.
    help : bool (default: True)
        Set to False to disable automatic help on -h or --help
        options.
    version : any object
        If passed, the object will be printed if --version is in
        `argv`.
    options_first : bool (default: False)
        Set to True to require options preceed positional arguments,
        i.e. to forbid options and positional arguments intermix.

    Returns
    -------
    args : dict
        A dictionary, where keys are names of command-line elements
        such as e.g. "--verbose" and "<path>", and values are the
        parsed values of those elements.

    Example
    -------
    >>> from docopt import docopt
    >>> doc = '''
    Usage:
        my_program tcp <host> <port> [--timeout=<seconds>]
        my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
        my_program (-h | --help | --version)

    Options:
        -h, --help  Show this screen and exit.
        --baud=<n>  Baudrate [default: 9600]
    '''
    >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30']
    >>> docopt(doc, argv)
    {'--baud': '9600',
     '--help': False,
     '--timeout': '30',
     '--version': False,
     '<host>': '127.0.0.1',
     '<port>': '80',
     'serial': False,
     'tcp': True}

    See also
    --------
    * For video introduction see http://docopt.org
    * Full documentation is available in README.rst as well as online
      at https://github.com/docopt/docopt#readme

    Nr1css�|]	}|j|jfVqdSrrSr[r
r
rrjBs�zdocopt.<locals>.<genexpr>)r��argvr�r
rr�r�r�r�r�r$r%r&r8rEr"r�r!rcr�)
r�r�r�r�r�r�r��pattern_options�ao�doc_optionsr�r`rar
r
rr�s"?
�r~)NTNF)%r	r�rw�__all__�__version__�	Exceptionrrr
�objectrrQrhr7r<r8rCrDrErFrAr$r�r�r�r�r�r�r�r�r�r�r�r��dictr�rr
r
r
r�<module>s@
K!(
	
!#