3

�S4b'3�@s�dd
lZdd
l
Z
dd
lZddlmZmZmZ
dd
lZddlm	Z	m
Z
mZ
Gdd�de�ZGdd�de�Z
Gdd	�d	e�ZGd
d�de�Zdd
d�
Zdd�Zddd�
Zdd�Zdd�Zd
S)�N)�ArgumentParser�_SubParsersAction�RawDescriptionHelpFormatter)�CommandDefinitionError�
UsageError�CommandErrorcs$eZ
dZ�f
d
d�Zdd�Z�ZS)�_LeappArgumentParserc

stt
|�jtjd
�

dS)N)
�file)�superr�
print_help�sys�stderr)
�self)
�	__class__��)/root/tmp_leapp_py3/leapp/utils/clicmd.pyr
s
z_LeappArgumentParser.print_helpcCs&|j�
t
jjd
|
�

t
jd�

dS)Nz
error: %s
�)rrr
�write�exit)r�messagerrr�errors


z_LeappArgumentParser.error)�__name__�
__module__�__qualname__rr�
__classcell__rr)
rrrs
rcs eZ
dZd
Z�f
dd�Z�ZS)�_LeappHelpFormatterz9
    Capitalizes section headings in the help output
    cstt
|�j|
j��
S)
N)r
r�
start_section�
capitalize)rZheading)
rrrrs
z!_LeappHelpFormatter.start_section)rrr�__doc__rrrr)
rrrs
rcs"eZ
dZd
Zd�f
dd�	Z�ZS)�_SubParserActionOverridea�

    This class implements a workaround for an issue fixed in 2.7.9.
    See https://bugs.python.org/issue9351

    TL;DR: Before, 2.7.9 argparse._SubParserAction did not propagate sub parser default values
    to the global namespace when they were already defined .
    This implementation is a workaround to override those values additionally.

    The additional code will not be executed if python 2.7.9 or higher is found.
    Nc
s|tt
|�j|
|||�
tjdkr$dS|d}|dd�}|j|}
|
j|d�\}}x$t|�
j�D]\}}	t	|||	�
q`WdS)Nr��	r
�
)rr r!)
r
r�__call__r�version_infoZ_name_parser_map�parse_known_args�vars�items�setattr)
r�parser�	namespace�valuesZ
option_stringZparser_nameZarg_stringsZ
sub_namespace�key�value)
rrrr#)s










z!_SubParserActionOverride.__call__)
N)rrrrr#rrr)
rrrs

rc
@s|eZ
dZd
Zddd�
Zdd�Zdd	�Zd
d�Zddd
�
Zdd�Z	dd�Z
dd�Zddddedddddf
dd�
Z
ddd�
ZdS)�CommandzW
    Command implements a convenient command-based argument parsing the framework.
    N�cCs8|
|_||_
|p||_i|_g|_||_d
|_d
|_d
S)ai

        :param name: Name of the sub command
        :type name: str
        :param target: Function called when the command is invoked
        :type target: Callable
        :param help: Shows a help message
        :type help: str
        :param description: Extended description of the command (the default is `help`)
        :type description: str
        N)�name�help�description�
_sub_commands�_options�target�parentr))rr0r5r1r2rrr�__init__9s







zCommand.__init__cCs�tt
jjtjd
�
td�}|jddt�
|j	dd|
d�
|j
dd	�

|jr`|jd
dd�}d
|_
n|}|j||d�
|j�\}}|r�|jj�d}|j|jj|�

|j|�

dS)z�
        Entry point to the command execution. It is used for the main entry function of an application.

        :param version: Version string to display for --version calls
        :type version: str
        :return: None
        r
)�prog�formatter_class�action�parsersz	--version�version)r:r<N)
�funczRequired arguments�command)�title�metavarT)
r)r"���)r�os�path�basenamer�argvr�registerr�add_argument�set_defaultsr3�add_subparsersZrequired�apply_parserr%r8�splitr)rr=)rr<r)�
s�argsZleftoverZcmdnamerrr�executeMs









zCommand.executec

Csd
d�|jD�
S)zK
        :return: Returns all options that are marked as 'inherit'
        c
Ssg|]}
|
djd
�
r|
�qS)r�inherit)
�get)�.0Zoptionrrr�
<listcomp>psz3Command.get_inheritable_options.<locals>.<listcomp>)
r4)
rrrr�get_inheritable_optionslszCommand.get_inheritable_optionscCs�y&|jr|jj
|
�

|jr$|j|
�

Wn�tk
rl
}
z*|jj�
|jjd
dj|jd�
d�
WYdd}~Xn<t	k
r�
}
z |jjd
dj|jd�
d�
WYdd}~XnXdS)ab

        The actual call is dispatched through this method. It ensures that the parent is also called
        to allow generic handling of some flags (especially inherited flags).

        :param args: Arguments object that is a result of the `argparse` commandline parser
        :type args: :py:class:`argparse.Namespace`
        :return: None
        rz
UsageError: {message}
)
r)�statusrNz
Error: {message}
)
r6�calledr5rr)rr�formatrr)rrM�
errrrUrs	






*

zCommand.calledcCs
|j|k	rd
S|r||_
n|
j|j|jtd|jd�|_
|j
j|j
j|j	d�
|j
j
ddt�
g}|j}x|r�||j�7}|j}qjWx&|j
|D]\}}}|j
j||�

q�W|jr�|s�|j
j|j
jd|jdd	�}	n|
}	x$|jj�D]\}
}|j|	|d
�
q�Wd
S)ab

        :param sparser: ArgumentParser.add_subparsers
        :type sparser: _SubParserActionOverride
        :param parent: Instance of :py:class:`_Command`
        :type parent: _Command
        :param parser: ArgumentParser instance usually received from sparser.add_parser
        :type parser: argparse.ArgumentParser
        :return: None
        NzDescription:

)r1r9r2)r8r=r:r;zAvailable subcommandsr/)r8r?r1r@)
r6)r6r)Z
add_parserr0r1rr2rHr8rUrFrrSr4rGr3rIr'rJ)rZsparserr6r)�inheritable�currentrM�kwargs�internalZsubsr0�cmdrrrrJ�s.



















zCommand.apply_parsercCsBt|
t
�s,tt|
d
d�t
�r$|
j}
ntd�
�
||
_|
|j|
j<|S)z�
        Adds a sub command to this command

        :param cmd: The sub command object
        :type cmd: :py:class:`leapp.utils.clicmd.Command`
        :return: self
        r>NzGExpected instance of Command or decorated command function as parameter)�
isinstancer.�getattrr>�	TypeErrorr6r3r0)rr\rrr�add_sub�s





zCommand.add_subc
Os||d
<t|
|�
S)Nr6)
r>)rrMrZrrrr#�s

zCommand.__call__c
Os"|jd
i�}|j
j|
||f�

dS)Nr[)�popr4�append)rrMrZr[rrr�_add_opt�s

zCommand._add_optFcCs�|
jd
�
}
d|
g
}i}
|rJ|jd
�
}t
|�
dkr:td�
�
|jdd
|�
|shd}|r\d}n|rh||
d<|	rt|	|
d	<|
r�|
|
d
<|r�||
d<|j|||||d�d
�|
��

|S)a�
        Add an option

        :param name: Name of the option
        :type name: str
        :param short_name: Short name of the option (one letter)
        :type short_name: str
        :param help: Help string for the option
        :type help: str
        :param is_flag: Decides if it is a flag
        :type is_flag: bool
        :param inherit: Decides if this option should be inherited by sub commands
        :type inherit: bool
        :param value_type: Type of the value by default string
        :param wrapped: Function that is wrapped (aka the target)
        :type wrapped: Callable
        :param action: ArgumentParser actions to take (e.g. store)
        :type action: str
        :param metavar: Changes the display name of arguments in generated help messages.
                        It has no influence on the attribute name from the generated arguments namespace.
        :type metavar: str
        :param choices: range of values that the argument is allowed to take
        :type choices: list
        :param choices: default value of the argument if nothing is specified
        :type choices: str
        :return: self
        �
-z--r"z$Short name should be one letter onlyr
Zstore�
store_true�typer@�choices�default)�wrappedrO)r1r:r[)�lstrip�lenr�insertrc)rr0Z
short_namer1Zis_flagrO�
value_typerir:r@rgrh�namesrZrrr�
add_option�s.
























zCommand.add_optioncCs&|j|
j
d
d�||ptd|i
d�
|S)zx

        :param name:
        :param value_type:
        :param help:
        :param wrapped:
        :return:
        rd�
_ri)r1rfr[)rc�replace�str)rr0rmr1rirrrrG�s	

zCommand.add_argument)Nr/N)NN)Nr/N)rrrrr7rNrSrUrJr`r#rcrrrorGrrrrr.5s


(

4r.r/cs��
��fd
d�}|S)a�

    Decorator to mark a function as a sub command

    :param name: Sub command name
    :type name: str
    :param help: Help string for the sub command
    :type help: str
    :param description: Extended description for the sub command defaults to help if it is not set
    :type description: str
    :param parent: Instance to the parent command if it is a sub-command
    :type parent: Command
    c

sVt|d
�st
��
|�d�|_n$�|j_�
|j_�p4�
|j_||j_�rR�j|j�

|S)Nr>)r1r5r2)�hasattrr.r>r0r1r2r5r`)
�
f)r2r1r0r6rr�wrapper
s









zcommand.<locals>.wrapperr)r0r1r2r6rur)r2r1r0r6rr>
s
r>c
stj
��
�f
d
d��
}
|
S)Nc

st|d
�st
d�
|_�|�
S)Nr>r/)rsr.r>)
rt)
rirrru)
s



z _ensure_command.<locals>.wrapper)�six�wraps)rirur)
rir�_ensure_command(
s
rxcst��
�fd
d��
}|S)z�
    Decorator wrapping functions to add command line arguments to the sub command to be invoked

    :param name: Name of the argument
    :param value_type: Type of the argument
    :param help: Help string for the argument
    c

s|jj
�
��|d
�
|S)N)rmr1ri)r>rG)
rt)r1r0rmrrru9
s

zcommand_arg.<locals>.wrapper)
rx)r0rmr1rur)r1r0rmr�command_arg1
sryc
st��
fd
d��
}|S)z�
    Decorator wrapping functions to add command line options to the sub command to be invoked

    :param name: Name of the option
    :param kwargs: parameters as specified in :py:func:`leapp.utils.clicmd.Command.add_option`
    c

s|jj
�
f
d
|i
���

|S)Nri)r>ro)
rt)rZr0rrruH
s
zcommand_opt.<locals>.wrapper)
rx)r0rZrur)rZr0r�command_optA
srzc
Cs&f}
t|d
�rd}
t
j|tj|
d�S)z�
    Decorator passing the command attribute of the wrapped function to the wrapper

    This needs to be used by decorators that are trying to wrap clicmd decorated command functions.
    r>)
�assigned)
r>)rsrvrw�	functools�WRAPPER_ASSIGNMENTS)rtZ
additionalrrr�command_aware_wrapsO
s



r~)r/NN)Nr/)r|rBr�argparserrrrvZleapp.exceptionsrrrrrr�objectr.r>rxryrzr~rrrr�<module>
s


X