Current File : //usr/lib/python2.7/site-packages/salt/utils/args.pyo
�
���^c @@ s� d Z d d l m Z m Z 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
Z
d d l m Z d d l
m Z d d l m Z m Z d d l Z d d l Z d d l Z d d l Z e j e � Z e j r e j d e j � Z n e j d � Z d � Z e d � Z d
� Z! e d d � Z# d � Z$ d
� Z% e j r�d d l& m' Z' e' d d � Z( d � Z) n d d � Z* d � Z+ d d � Z, d d � Z- d d � Z. d � Z/ d d d d � Z0 d � Z1 d � Z2 d S( u*
Functions used for CLI argument handling
i ( t absolute_importt print_functiont unicode_literalsN( t SaltInvocationError( t six( t mapt zipu ^([^\d\W][\w.-]*)=(?!=)(.*)$c K@ sF i } x9 t j | � D]( \ } } | j d � s | | | <q q W| S( u�
Return a dict without any of the __pub* keys (or any other keys starting
with a dunder) from the kwargs dict passed into the execution module
functions. These keys are useful for tracking what was used to invoke
the function call, but they may not be desirable to have if passing the
kwargs forward wholesale.
Usage example:
.. code-block:: python
kwargs = __utils__['args.clean_kwargs'](**kwargs)
u __( R t iteritemst
startswith( t kwargst rett keyt val( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt clean_kwargs! s
c C@ s� | rU t | t � rU g t j | � D] \ } } d j | | � ^ q% } | } qU n d j d j | � � } | r� t | � � n | Sd S( uD
Raise a SaltInvocationError if invalid_kwargs is non-empty
u {0}={1}u2 The following keyword arguments are not valid: {0}u , N( t
isinstancet dictR R t formatt joinR ( t invalid_kwargst raise_exct xt yt new_invalidt msg( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyR 6 s 1 c C@ s� g } x� | D]} } t j rL t | t j � rL t j j j t j | � � sd t j r} t | t
� r} | j t j | � � q
| j | � q
Wt | t � r� | r� i t
d 6} x' t j | � D] \ } } | | | <q� W| | g S| S( uG
Return a single arg structure for the publisher to safely use
u __kwarg__( R t PY3R t
integer_typest saltt utilst jidt is_jidt text_typet PY2t longt appendR t TrueR ( t argsR R
t argt kw_R R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt condition_inputK s
9
c C@ s | d k r d } n g } i } x� | D]� } t | t j � r� t | � \ } } | r} | | k rp t | � n | | | <q� | j t | � � q( t | t � r� | j d t � t
k r� | j | � q� | j | � q( | j | � q( W| r� t | | � S| | f S( u�
Parse out the args and kwargs from a list of input values. Optionally,
return the args and kwargs without passing them to condition_input().
Don't pull args with key=val apart if it has a newline in it.
u __kwarg__N( (
t NoneR R t string_typest parse_kwargt yamlify_argR! R t popt FalseR" t updateR& ( R# t conditiont no_parset _argst _kwargsR$ t arg_namet arg_value( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt parse_input^ s&
c C@ s0 y t j | � j � SWn t k
r+ d SXd S( u�
Parses the string and looks for the following kwarg format:
"{argument name}={argument value}"
For example: "my_message=Hello world"
Returns the kwarg name and value, or (None, None) if the regex was not
matched.
N( NN( t KWARG_REGEXt matcht groupst AttributeErrorR' ( t string_( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyR) � s
c C@ s t | t j � s | S| j � d k r, | Sd | k rg t g | j � D] } | d k ^ qH � rg | Sy�d d l } | } d | k r� | j j j | � } t | t j � s� | d k r� | S| S| d k r� d } n | j j j | � } t | t
� r)t | t j � r"| j d � r"| S| Sn� t | t � ret | t j � r^| j d � r^| S| Sn� | d k s�t | t t
t j t j f � r�| d k r�| d k r�| S| d k r�| j � j d � r�| S| d k r�| d k r�| S| Sn | SWn t k
r| SXd S(
u
yaml.safe_load the arg
u u _u 0123456789_i Nu #u Noneu {u [u |u !( u |u !( R R R( t stript allt salt.utils.yamlR t yamlt safe_loadR' R R t listt floatR t Exception( R$ R R t original_argt
parsed_arg( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyR* � sN 7 !!
( t
namedtupleu ArgSpecu args varargs keywords defaultsc C@ sR t j | � \ } } } } } } } | s0 | r? t d � � n t | | | | � S( u�
Python 3 wrapper for inspect.getargsspec
inspect.getargsspec is deprecated and will be removed in Python 3.6.
uc Function has keyword-only arguments or annotations, use getfullargspec() API which can support them( t inspectt getfullargspect
ValueErrort _ArgSpec( t funcR# t varargst varkwt defaultst
kwonlyargst _t ann( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt _getargspec� s $ c C@ s� t | � s$ t d j | � � � n t j r� | t k rU t j | � } | j d =q�t j | � rv t j | � } q�t j
| � r� t j | � } | j d =q�t | t � r� t j | j
� } | j d =q�t d j | � � � n� | t k r t | � } | j d =n� t j | � r*t | � } nh t j
| � rRt | � } | j d =n@ t | t � r}t | j
� } | j d =n t d j | � � � | S( u�
A small wrapper around getargspec that also supports callable classes
:param is_class_method: Pass True if you are sure that the function being passed
is a class method. The reason for this is that on Python 3
``inspect.ismethod`` only returns ``True`` for bound methods,
while on Python 2, it returns ``True`` for bound and unbound
methods. So, on Python 3, in case of a class method, you'd
need the class to which the function belongs to be instantiated
and this is not always wanted.
u {0} is not a callablei u& Cannot inspect argument list for '{0}'( t callablet TypeErrorR R R R" RE t
getargspecR# t
isfunctiont ismethodR t objectt __call__RP ( RI t is_class_methodt aspec( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt get_function_argspec� s<
c K@ sH t | t j � r@ t j j j t j t j j j
| � | � � S| Sd S( u,
Only split if variable is a string
N( R R R( R R t datat decodet shlext splitt stringutilst to_str( t sR ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt shlex_split# s "c C@ s� i i d 6} | d k r( t | � } n | j rm t t | j d d d � | j d d d � � � | d <n g | j D] } | | d k rw | ^ qw | d <| S( u[
Return a dict containing the arguments and default arguments to the
function.
u kwargsNi����u args( R' RZ RL R R R# ( t funRY R
R$ ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt
arg_lookup3 s
<0u c
C@ s� i } d | k s d | k r� x�t j | | � D]� } y t | | � } Wn t k
ra q1 n X| \ } } } } i | | <| r� | n d | | d <| r� | n d | | d <| r� t n d | | d <| r� t n d | | d <q1 Wn� | d } x� | D]� } | j | � r� y t | | � } Wn t k
r=q� n X| \ } } } } i | | <| rf| n d | | d <| r�| n d | | d <| r�t n d | | d <| r�t n d | | d <q� q� W| S( us
Pass in a functions dict as it is returned from the loader and return the
argspec function signatures
u *u .u argsu defaultsu varargsu kwargsN( t fnmatcht filterRZ RR R' R" R (
t functionst moduleR
Rc RY R# RJ R RL t
module_dot( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt argspec_reportA s6
!
!c C@ s� | d k r d � } n t | t � r: t t | | � � Sy9 t t | g | j d � D] } | j � ^ qV � � SWnL t k
r� t t | g t j | � j d � D] } | j � ^ q� � � SXd S( uT
Take an input value and split it into a list, returning the resulting list
c S@ s | S( N( ( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt <lambda>s s u ,N( R' R R? R R^ R: R8 R R ( R t mapperR ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt split_inputn s 9
c K@ sv d d l } xc t j | � D]R \ } } y/ | j � d k rV | j j j | � rV t SWq t k
rm q q Xq Wt S( u�
Examines the kwargs passed and returns True if any kwarg which matching
"Test" in any variation on capitalization (i.e. "TEST", "Test", "TeSt",
etc) contains a True value (as determined by salt.utils.data.is_true).
i Nu test(
t
salt.utilsR R t lowerR R[ t is_trueR" R8 R, ( R R R$ t value( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt test_mode| s '
c C@ s� | d k r | p i } g | d <i | d <t | d | �} t | | � } | d } | d } | j � } g }
x9 | D]1 } y | j | � | | <Wqz t k
r� qz Xqz WxX | r | j d � } y | d j | j | � � Wq� t k
r|
j | � q� Xq� W|
rpt | d � t | � }
|
t |
� } t d j | j
| | d k r^d pad |
� � � n | d j | � | j r�x= t
j | � D], \ } } | | k r�q�n | | d | <q�W| Si } xB t
j | � D]1 \ } } | | k rq�n t j | � | | <q�W| r�t | � d k rpd j t | j � � | j d
d j | j | j
� � � } nl d j d
j g | D] } d j | � ^ q�d � t | j � � d | j d
d j | j | j
� � � } t | � � n | S( u�
Build the required arguments and keyword arguments required for the passed
function.
:param fun: The function to get the argspec from
:param data: A dictionary containing the required data to build the
arguments and keyword arguments.
:param initial_ret: The initial return data pre-populated as dictionary or
None
:param expected_extra_kws: Any expected extra keyword argument names which
should not trigger a :ref:`SaltInvocationError`
:param is_class_method: Pass True if you are sure that the function being passed
is a class method. The reason for this is that on Python 3
``inspect.ismethod`` only returns ``True`` for bound methods,
while on Python 2, it returns ``True`` for bound and unbound
methods. So, on Python 3, in case of a class method, you'd
need the class to which the function belongs to be instantiated
and this is not always wanted.
:returns: A dictionary with the function required arguments and keyword
arguments.
u argsu kwargsRX i u. {0} takes at least {1} argument{2} ({3} given)i u su u1 '{0[0]}' is an invalid keyword argument for '{1}'u fullu {0}.{1}u5 {0} and '{1}' are invalid keyword arguments for '{2}'u , u '{0}'i����N( R' RZ Rd t copyR+ t KeyErrorR! t lenR R t __name__R- t keywordsR R t deepcopyR? t keyst gett
__module__R ( Rc R[ t initial_rett expected_extra_kwsRX R
RY t arg_dataR# R t missing_argsR R$ t used_args_countt
args_countRq t extraR t e( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt format_call� sp
!, c
C@ s t j | d t �} d | _ g } g } i } g } d } d } x+ | D]# } | d k r_ Pn | j | � qI W| s� | d k r� d Sd j | � } g } t } xC| D];} | d k r� | j | � | j | � q� | d k s� | d k rW| rW| rd j | � | | <n | r2| j d j | � � n | d k rHt } Pn d } g } q� | d k r�| s�| i d d
6d d 6d d 6| j � k r�Pn | j | � q� | d
k r�| r�d j | � } g } q� q� | j | � q� W| r�| | | f Sd Sd S( u�
Parse a python-like function call syntax.
For example: module.function(arg, arg, kw=arg, kw=arg)
This function takes care only about the function name and arguments list carying on quoting
and bracketing. It doesn't perform identifiers and other syntax validity check.
Returns a tuple of three values: function name string, arguments list and keyword arguments
dictionary.
t posixu "'u (u u [{(u ,u )u ]})u ]u [u }u {u =N( NNN( NNN( R] R" t
escapedquotesR' R! R R, R+ (
Ra t sht wordR# R t bracketsR t tokent fnamet good( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt parse_function sV
2
c C@ sz i } i } xa t j | � D]P \ } } | | k rS | d k r | | | <q q n | d k r | | | <q q W| | f S( u
Filter out the kwargs used for the init of the class and the kwargs used to
invoke the command required.
all_kwargs
All the kwargs the Execution Function has been invoked.
class_init_kwargs
The kwargs of the ``__init__`` of the class.
N( R R R' ( t
all_kwargst class_init_kwargst
fun_kwargst init_kwargst kargt warg( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt prepare_kwargs> s
( (3 t __doc__t
__future__R R R Rs Re RE t loggingt reR] t salt.exceptionsR t salt.extR t salt.ext.six.movesR R t salt.utils.dataR t salt.utils.jidt salt.utils.versionsR< t getLoggerRv t logR t compilet UNICODER5 R
R" R R& R' R4 R) R* t collectionsRD RH RP RZ Rb Rd Rj Rm Rr R� R� R� ( ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/args.pyt <module> sN # M 1 - r ;
Mini Shell