�
��fz- � �@ � S SK r S SKJr S SKJrJrJr S SKJ r S SK
J r S SK J
r
S SKJr S SKJr \R$ r " S S
\5 r " S S \5 r " S
S\5 r " S S\5 r " S S\5 rS rS rS r\" S5 r S r S SSSSS.S jjr \ S 5 r g) � N)�compile)� signature�getdoc� Parameter)�ArgumentParser)�contextmanager)�wraps)�IOBase)�AutocommandErrorc � � \ rS rSrSrSrg)�AnnotationError� zEAnnotation error: annotation must be a string, type, or tuple of both� N��__name__�
__module__� __qualname__�__firstlineno__�__doc__�__static_attributes__r � �7/usr/lib/python3/dist-packages/autocommand/autoparse.pyr
r
s � �Or r
c � � \ rS rSrSrSrg)�PositionalArgError�# zI
Postional Arg Error: autocommand can't handle postional-only parameters
r Nr r r r r r # s � �r r c � � \ rS rSrSrSrg)�
KWArgError�) z:kwarg Error: autocommand can't handle a **kwargs parameterr Nr r r r r r ) s � �Dr r c � � \ rS rSrSrSrg)�DocstringError�- zDocstring errorr Nr r r r r r - s � �r r c � � \ rS rSrSrSrg)�TooManySplitsError�1 z�
The docstring had too many ---- section splits. Currently we only support
using up to a single split, to split the docstring into description and
epilog parts.
r Nr r r r r# r# 1 s � �r r# c � � U [ L a g[ U 5 ( a U S4$ [ U [ 5 ( a SU 4$ [ U [ 5 ( aU U u p[ U5 ( a [ U[ 5 ( a X4$ [ U[ 5 ( a [ U5 ( a X!4$ [
U 5 e! [
a n[
U 5 UeSnAff = f)z�
Given an annotation, return the (type, description) for the parameter.
If you provide an annotation that is somehow both a string and a callable,
the behavior is undefined.
)NNN)�_empty�callable�
isinstance�str�tuple�
ValueErrorr
)�
annotation�arg1�arg2�es r �_get_type_descriptionr0 9 s� � � �V��� �*� � ��4� � � �J�� $� $��Z� � � �J�� &� &� "�#�J�D� ��~�~�*�T�3�"7�"7��z�!��D�#�&�&�8�D�>�>��z�!�
�*�
%�%�� � 5�!�*�-�1� 4�� 5�s �B- �-
C�7 C�Cc �( � U R U R L a [ U 5 eU R U R L a [ U 5 e0 nSn[ U R 5 u pgU R nUc U[ S1; a [ U5 nU[ La X�S' SnUbJ U[ L a U( a U[ L a SUS' OSUS' SnO#[ U[ 5 ( a
[ US' OXdS' U R U R L a S US
' Ub XtS ' / n U R n
U( a� U
S U
S R! 5 4 H; n X�; d M
UR# U 5 U R% S
R' U 5 5 O [) U
5 S:� d U ( d U R% SR' U
5 5 X�S' OU R% U
5 UR* " U 0 UD6 U( a7 U[ L a- UR+ SR' U
5 SU
U[ La UOSS9 ggg)a~
Add the argument(s) to an ArgumentParser (using add_argument) for a given
parameter. used_char_args is the set of -short options currently already in
use, and is updated (if necessary) by this function. If add_nos is True,
this will also add an inverse switch for all boolean options. For
instance, for the boolean parameter "verbose", this will create --verbose
and --no-verbose.
FN�defaultT�
store_true�action� store_false�type�*�nargs�helpr z-{}� z--{}�destz--no-{}� store_const)r4 r; �const)�kind�POSITIONAL_ONLYr � VAR_KEYWORDr r0 r, r2 r& r6 �boolr( r
r) �VAR_POSITIONAL�name�swapcase�add�append�format�len� add_argument) �param�parser�used_char_args�add_nos�arg_spec� is_option�arg_type� descriptionr2 �flagsrC �letters r �_add_argumentsrT S s � �
�z�z�U�*�*�*� ��'�'� ���u�(�(� (��� � � �H��I� 2�%�2B�2B� C��H� �m�m�G� ��G�F�D�>� 9���=�� �f� � %���� � �� �t� ��g�� /�%1���"�%2���"� �I� ���
(�
(� "�H�V� � (�V� �
�z�z�U�)�)�)� ���� � �&���
�E� �:�:�D���1�g�t�A�w� /� /� 1�1�F��+� �"�"�6�*�� � �U�\�\�&� 1�2�� 2� �t�9�q�=�� �L�L�� � �t�,� -� ���
� � �T��
����+�(�+� �8�t�#���� � � �T� "� �� $�F� 2�'�� � ?� $�wr c � � [ XS9nS1n[ U R R 5 S S9nU H n[ XtXS5 M U$ )z=
Given the signature of a function, create an ArgumentParser
)rQ �epilog�hc �2 � [ U R 5 S:� $ �Nr: )rH rC )rJ s r �<lambda>� make_parser.<locals>.<lambda>� s � �#�e�j�j�/�A�-r )�key)r �sorted�
parameters�valuesrT )�func_sigrQ rV rM rK rL �paramsrJ s r � make_parserrb � sS � � � �
C�F��U�N�
����"�"�$� -�/�F� ���u�n�>� � �Mr z\n\s*-{4,}\s*\nc � � U c g[ R U 5 n[ U5 S:X a U S4$ [ U5 S:X a
US US 4$ [ 5 e)z@
Given a docstring, parse it into a description and epilog part
)� rd r: rd � r )�_DOCSTRING_SPLIT�splitrH r# )� docstring�partss r �parse_docstringrj � sY � � ��� � "� "�9� -�E�
�5�z�Q���"�}� � �U��q� ��Q�x��q��!�!� �"�"r F�rQ rV rM rK c � ^ ^^^^^� T c UUUU4S j$ [ T 5 m[ [ T 5 5 u pVTc [ TT=( d UT=( d UT5 m[ T 5 SU UU4S jj5 nT Ul TUl U$ )a�
This decorator converts a function that takes normal arguments into a
function which takes a single optional argument, argv, parses it using an
argparse.ArgumentParser, and calls the underlying function with the parsed
arguments. If it is not given, sys.argv[1:] is used. This is so that the
function can be used as a setuptools entry point, as well as a normal main
function. sys.argv[1:] is not evaluated until the function is called, to
allow injecting different arguments for testing.
It uses the argument signature of the function to create an
ArgumentParser. Parameters without defaults become positional parameters,
while parameters *with* defaults become --options. Use annotations to set
the type of the parameter.
The `desctiption` and `epilog` parameters corrospond to the same respective
argparse parameters. If no description is given, it defaults to the
decorated functions's docstring, if present.
If add_nos is True, every boolean option (that is, every parameter with a
default of True/False or a type of bool) will have a --no- version created
as well, which inverts the option. For instance, the --verbose option will
have a --no-verbose counterpart. These are not mutually exclusive-
whichever one appears last in the argument list will have precedence.
If a parser is given, it is used instead of one generated from the function
signature. In this case, no parser is created; instead, the given parser is
used to parse the argv argument. The parser's results' argument names must
match up with the parameter names of the decorated function.
The decorated function is attached to the result as the `func` attribute,
and the parser is attached as the `parser` attribute.
c � >� [ U TTTTS9$ )Nrk )� autoparse)�frM rQ rV rK s ����r rZ �autoparse.<locals>.<lambda> s �� ��
�;���� r c �� >� U c [ R SS n TR 5 nUR R [ TR
U 5 5 5 T" UR 0 UR D6$ rY ) �sys�argv� bind_partial� arguments�update�vars�
parse_args�args�kwargs)rs � parsed_args�funcr` rK s ���r �autoparse_wrapper�$autoparse.<locals>.autoparse_wrapper" sg �� � �<��8�8�A�B�<�D�
�+�+�-� �� � �$�$�T�&�*;�*;�D�*A�%B�C��[�%�%�<��);�);�<�<r �N)r rj r rb r r| rK ) r| rQ rV rM rK �docstr_description�
docstr_epilogr} r` s ````` @r rn rn � s� �� �P �|�� � ���H�(7��t� �(E�%��
�~� � � � -�-� � #�m� � �� �4�[�
=�
=� �
=� "��� %�� � � r c / � # � [ U [ [ [ 45 ( a [ U /UQ70 UD6 nUv � SSS5 gU v � g! , ( d f g= f7f)a%
This context manager allows you to open a filename, if you want to default
some already-existing file object, like sys.stdout, which shouldn't be
closed at the end of the context. If the filename argument is a str, bytes,
or int, the file object is created via a call to open with the given *args
and **kwargs, sent to the context, and closed at the end of the context,
just like "with open(filename) as f:". If it isn't one of the openable
types, the object simply sent to the context unchanged, and left unclosed
at the end of the context. Example:
def work_with_file(name=sys.stdout):
with smart_open(name) as f:
# Works correctly if name is a str filename or sys.stdout
print("Some stuff", file=f)
# If it was a filename, f is closed at the end here.
N)r( r) �bytes�int�open)�filename_or_filery rz �files r �
smart_openr� 7 sN � � �$ �"�S�%��$5�6�6�
�"�
4�T�
4�V�
4���J� 5�
4� � � 5�
4�s �0A�A�A�
A�Ar ) rr �rer �
compile_regex�inspectr r r �argparser �
contextlibr � functoolsr �ior
�autocommand.errorsr �emptyr& r
r r r r# r0 rT rb rf rj rn r� r r r �<module>r� s� ��$ � '� 0� 0� #� %� � � /�
� � ��P�&� P��)� � E�!� E��%� �� � �&�4i?�X�* !�!3�4� �#�$ �L ����� L �^ � � � r