Current File : //lib/python2.7/site-packages/salt/utils/data.pyc
�
���^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 y d d l m
Z
m Z m Z Wn- e
k
r� d d l m
Z
m Z m Z n Xd 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 d d l m Z d d l m Z d d
l m Z e j e � Z! d e f d � � YZ" e# d
� Z$ e# d � Z% e# d � Z& e d � d d d � � Z( e d � d d d � � Z) d d e# e# e# e# e# d � Z* d d e# e# e# e# e# d � Z+ d d e# e# e# e# e# d � Z, d d e# e# e# e# d � Z- d d e# e# e# d � Z. e d � e d � d d e# e# e# d � � � Z/ e d � e d � d d e# e# e# d � � � Z0 d d e# e# d � Z1 e d! � d" d# � � Z2 e d$ � d% � � Z3 d d& d d' � Z4 d e d( � Z5 e d) � d e d* � � Z6 e e# e# d+ � Z7 e d, � d- � � Z8 d. � Z9 e# e# d d d/ � Z: e d0 � d1 � � Z; e d2 � e j< d3 � � Z= e d4 � d5 � � Z> d d6 � Z? e d7 � d8 � � Z@ d9 � ZA d: � ZB d S(; uc
Functions for manipulating, inspecting, or otherwise working with data types
and data structures.
i ( t absolute_importt print_functiont unicode_literalsN( t Mappingt MutableMappingt Sequence( t DEFAULT_TARGET_DELIM( t
SaltException( t jinja_filter( t OrderedDict( t six( t ranget CaseInsensitiveDictc B@ sk e Z d Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
RS( uq
Inspired by requests' case-insensitive dict implementation, but works with
non-string keys as well.
c K@ s& t � | _ | j | p i | � d S( uy
Force internal dict to be ordered to ensure a consistent iteration
order, irrespective of case.
N( R t _datat update( t selft initt kwargs( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __init__) s c C@ s
t | j � S( N( t lenR
( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __len__1 s c C@ s | | f | j t | � <d S( N( R
t to_lowercase( R t keyt value( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __setitem__4 s c C@ s | j t | � =d S( N( R
R ( R R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __delitem__8 s c C@ s | j t | � d S( Ni ( R
R ( R R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __getitem__; s c C@ s d � t j | j � D� S( Nc s@ s | ] } | d Vq d S( i N( ( t .0t item( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>? s ( R
t
itervaluesR
( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __iter__> s c C@ s; t | t � s t St | j � � t t | � j � � k S( N( t
isinstanceR t Falset dictt items_lowerR ( R t rval( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __eq__A s c C@ s t t t j | � � � S( N( t reprR! R
t iteritems( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt __repr__G s c C@ s d � t j | j � D� S( up
Returns a generator iterating over keys and values, with the keys all
being lowercase.
c s@ s% | ] \ } } | | d f Vq d S( i N( ( R R t val( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>O s ( R
R& R
( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR" J s c C@ s t t j | j � � S( u.
Returns a copy of the object
( R R
R& R
( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt copyQ s N( t __name__t
__module__t __doc__t NoneR R R R R R R$ R' R" R) ( ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR $ s c @ s� y t | � � � SWn t k
r' n X| j } t | t � rr � rL | n t � � f d � t j | � D� � St | t � r� | � � f d � | D� � S| Sd S( Nc 3@ s9 | ]/ \ } } t | � � � t | � � � f Vq d S( N( t
__change_case( R R R( ( t attrt preserve_dict_class( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>b s c 3@ s! | ] } t | � � � Vq d S( N( R. ( R R ( R/ R0 ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>h s ( t getattrt AttributeErrort __class__R R R! R
R& R ( t dataR/ R0 t data_type( ( R/ R0 s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR. X s
c C@ s t | d | � S( Nu lower( R. ( R4 R0 ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR m s c C@ s t | d | � S( Nu upper( R. ( R4 R0 ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt to_uppercaseq s u
compare_dictsc C@ s� i } x� t | p i � j | p$ i � D]� } | | k rY i d d 6| | d 6| | <q( | | k r� i d d 6| | d 6| | <q( | | | | k r( i | | d 6| | d 6| | <q( q( W| S( u�
Compare before and after results from various salt functions, returning a
dict describing the changes that were made.
u u oldu new( t sett union( t oldt newt retR ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt
compare_dictsu s (
u
compare_listsc C@ sa t � } x' | D] } | | k r | | d <q q Wx' | D] } | | k r: | | d <q: q: W| S( u�
Compare before and after results from various salt functions, returning a
dict describing the changes that were made
u newu old( R! ( R9 R: R; R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt
compare_lists� s
u strictc C@ s! | s t j j j n t j j j } t | t � rR t | | | | | | | | � St | t � r� t | | | | | | | | � St | t
� r� | r� t | | | | | | | � St | | | | | | | | � Sy | | | | | � } Wn- t k
r� n t
k
r| s� qn X| Sd S( ua
Generic function which will decode whichever type is passed, if necessary.
Optionally use to_str=True to ensure strings are str types and not unicode
on Python 2.
If `strict` is True, and `keep` is False, and we fail to decode, a
UnicodeDecodeError will be raised. Passing `keep` as True allows for the
original value to silently be returned in cases where decoding fails. This
can be useful for cases where the data passed to this function is likely to
contain binary blobs, such as in the case of cp.recv.
If `normalize` is True, then unicodedata.normalize() will be used to
normalize unicode strings down to a single code point per glyph. It is
recommended not to normalize unless you know what you're doing. For
instance, if `data` contains a dictionary, it is possible that normalizing
will lead to data loss because the following two strings will normalize to
the same value:
- u'\u044f\u0438\u0306\u0446\u0430.txt'
- u'\u044f\u0439\u0446\u0430.txt'
One good use case for normalization is in the test suite. For example, on
some platforms such as Mac OS, os.listdir() will produce the first of the
two strings above, in which "й" is represented as two code points (i.e. one
for the base character, and one for the breve mark). Normalizing allows for
a more reliable test case.
N( t saltt utilst stringutilst
to_unicodet to_strR R t decode_dictt listt decode_listt tuplet decode_tuplet TypeErrort UnicodeDecodeError( R4 t encodingt errorst keept normalizeR0 t preserve_tuplesRB t _decode_func( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt decode� s(
"
c
C@ s | s t j j j n t j j j } | r6 | j � n i } x�t j | � D]�\ }
} t |
t � r� | r� t
|
| | | | | | � n t |
| | | | | | | � }
nI y | |
| | | � }
Wn- t k
r� n t
k
r� | s� � q� n Xt | t � r+t | | | | | | | | � } n� t | t � r�| r^t
| | | | | | | � n t | | | | | | | | � } n| t | t � r�t | | | | | | | | � } nI y | | | | | � } Wn- t k
r�n t
k
r�| s�� q�n X| | |
<qL W| S( u�
Decode all string values to Unicode. Optionally use to_str=True to ensure
strings are str types and not unicode on Python 2.
( R> R? R@ RA RB R3 R
R& R RF RG RE RH RI RD R RC ( R4 RJ RK RL RM R0 RN RB RO t rvR R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRC � sD $
$
c
C@ sR | s t j j j n t j j j } g } x!| D]}
t |
t � rj t |
| | | | | | | � }
n� t |
t � r� | r� t |
| | | | | | � n t |
| | | | | | | � }
n| t |
t
� r� t |
| | | | | | | � }
nI y | |
| | | � }
Wn- t k
r n t
k
r<| s=� q=n X| j |
� q1 W| S( u�
Decode all string values to Unicode. Optionally use to_str=True to ensure
strings are str types and not unicode on Python 2.
( R> R? R@ RA RB R RD RE RF RG R RC RH RI t append( R4 RJ RK RL RM R0 RN RB RO RQ R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRE s.
$
c
C@ s% t t | | | | | | t | � � S( u�
Decode all string values to Unicode. Optionally use to_str=True to ensure
strings are str types and not unicode on Python 2.
( RF RE t True( R4 RJ RK RL RM R0 RB ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRG : s c C@ s� t | t � r( t | | | | | | � St | t � rP t | | | | | | � St | t � r� | r{ t | | | | | � St | | | | | | � Sy t j j j
| | | � SWn- t k
r� n t k
r� | s� � q� n X| Sd S( u�
Generic function which will encode whichever type is passed, if necessary
If `strict` is True, and `keep` is False, and we fail to encode, a
UnicodeEncodeError will be raised. Passing `keep` as True allows for the
original value to silently be returned in cases where encoding fails. This
can be useful for cases where the data passed to this function is likely to
contain binary blobs.
N(
R R t encode_dictRD t encode_listRF t encode_tupleR> R? R@ t to_bytesRH t UnicodeEncodeError( R4 RJ RK RL R0 RN ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt encodeF s$
u json_decode_dictu json_encode_dictc C@ s� | r | j � n i } x�t j | � D]�\ } } t | t � r | ra t | | | | | � n t | | | | | | � } nO y t j j j
| | | � } Wn- t k
r� n t k
r� | s� � q� n Xt | t
� r� t | | | | | | � } n� t | t � rF| r(t | | | | | � n t | | | | | | � } n| t | t � rst | | | | | | � } nO y t j j j
| | | � } Wn- t k
r�n t k
r�| s�� q�n X| | | <q( W| S( u+
Encode all string values to bytes
( R3 R
R& R RF RV RU R> R? R@ RW RH RX RD R RT ( R4 RJ RK RL R0 RN RQ R R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRT j s@
u json_decode_listu json_encode_listc C@ s g } x| D]} t | t � r@ t | | | | | | � } n� t | t � r� | rm t | | | | | � n t | | | | | | � } n| t | t � r� t | | | | | | � } nO y t j j j
| | | � } Wn- t k
r� n t k
r| s� qn X| j
| � q
W| S( u+
Encode all string values to bytes
( R RD RU RF RV R RT R> R? R@ RW RH RX RR ( R4 RJ RK RL R0 RN RQ R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRU � s*
c C@ s t t | | | | | t � � S( u-
Encode all string values to Unicode
( RF RU RS ( R4 RJ RK RL R0 ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRV � s u exactly_n_truei c @ s9 t | � � t � f d � t | � D� � o8 t � � S( ub
Tests that exactly N items in an iterable are "truthy" (neither None,
False, nor 0).
c 3@ s | ] } t � � Vq d S( N( t any( R t j( t i( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>� s ( t itert allR RZ ( t lt n( ( R\ s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt exactly_n� s u exactly_one_truec C@ s
t | � S( uI
Check if only one item is not None, False, or 0 in an iterable.
( Ra ( R_ ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt exactly_one� s u defaultc
C@ s� d } t | | g � } x� t | t � r0 | n | g D]� } x| | D]t } t | t j � rb | n t j | � }
t | t j � r� | n t j | � } t j | |
� rD | | } PqD qD W| d k r7 Pq7 q7 W| d k r� | j | d � } n | rv| | k rv| | } | d k r"| } qvt | t
� rvt | t
� sOt d � � n t j
j j t j | � | � } qvn | r�t | t
� s�t d � � n | d k r�| } q�t j
j j | t j | � � n | S( uF
Common code to filter data structures like grains and pillar
u? filter_by default and look-up values must both be dictionaries.u. filter_by merge argument must be a dictionary.N( R- t traverse_dict_and_listR RD R
t string_typest text_typet fnmatcht fnmatchcaset getR R R> R? t
dictupdateR R) t deepcopy(
t lookup_dictt lookupt traverset merget defaultt baseR; R( t eachR t test_keyt test_eacht base_values( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt filter_by� s@ %
' "c C@ sP | } y( x! | j | � D] } | | } q WWn t t t f k
rK | SX| S( u
Traverse a dict using a colon-delimited (or otherwise delimited, using the
'delimiter' param) target string. The target 'foo:bar:baz' will return
data['foo']['bar']['baz'] if this value exists, and will otherwise return
the dict in the default argument.
( t splitt KeyErrort
IndexErrorRH ( R4 R Ro t delimitert ptrRq ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt
traverse_dict s u traversec C@ s� | } x� | j | � D]� } t | t � r� y t | � } Wne t k
r� t } xA d � | D� D]/ } y | | } t } PWqb t k
r� qb Xqb W| s� | Sq� Xy | | } Wq� t k
r� | SXq y | | } Wq t t f k
r� | SXq W| S( u
Traverse a dict or list using a colon-delimited (or otherwise delimited,
using the 'delimiter' param) target string. The target 'foo:bar:0' will
return data['foo']['bar'][0] if this value exists, and will otherwise
return the dict in the default argument.
Function will automatically determine the target type.
The target 'foo:bar:0' will return data['foo']['bar'][0] if data like
{'foo':{'bar':['baz']}} , if data like {'foo':{'bar':{'0':'baz'}}}
then return data['foo']['bar']['0']
c s@ s$ | ] } t | t � r | Vq d S( N( R R! ( R t x( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>: s (
Rv R RD t intt
ValueErrorR RS Rw Rx RH ( R4 R Ro Ry Rz Rq t idxt embed_matcht embedded( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyRc & s2
c @ s� t t d � � t t � � f d � � | j | � } t | � } | d k rR t S| j | � } t | � } | d k r} t Sxnt | d d d � D]V} | j | | � } | d k r� | } | }
n+ | j | | � } t | | i d | �}
t j d | | | � |
i k rq� n t |
t � rO� |
| d | d
| �r� t
Sq� n t |
t t f � r�x^ |
D]V } t | t � r�� | | d | d
| �r�t
Sn � | | d | d
| �rkt
SqkWq� n � |
| d | d
| �r� t
Sq� Wt S( uf
Check for a match in a dictionary using a delimiter character to denote
levels of subdicts, and also allowing the delimiter character to be
matched. Thus, 'foo:bar:baz' will match data['foo'] == 'bar:baz' and
data['foo']['bar'] == 'baz'. The latter would take priority over the
former, as more deeply-nested matches are tried first.
c S@ s� y t j | � j � } Wn, t k
rG t j j j | � j � } n Xy t j | � j � } Wn, t k
r� t j j j | � j � } n X| r� y t j | | � SWq� t
k
r� t j d | � t
SXn | r� | | k St j | | � Sd S( Nu Invalid regex '%s' in match( R
Re t lowerRI R> R? R@ RA t ret matcht Exceptiont logt errorR Rf ( t targett patternt regex_matcht exact_match( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt _match] s
c @ s% | j d � } | r" | d } n | d k r2 t S| | k rB t St | | d | d | �ra t S| r!x� | D]� } t | | t � r� � | | | d | d | �rt Sqn t | | t � r� xW | | D]% } � | | d | d | �r� t Sq� Wqn � | | | d | d | �rn t Sqn Wn t S( Nu *:i u *R� R� ( t
startswithRS t
subdict_matchR R! RD R ( R� R� R� R� t wildcardR R ( t _dict_matchR� ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR� z sB
i i i����u *Ry u5 Attempting to match '%s' in '%s' using delimiter '%s'R� R� (
R Rv R R t joinRc R� t debugR R! RS RD RF ( R4 t exprRy R� R� t splitst
num_splitsR R t matchstrR� t member( ( R� R� s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR� Q s` &
u substring_in_listc @ s t � f d � | D� � S( u�
Return a boolean value that indicates whether or not a given
string is present in any of the strings which comprise a list
c 3@ s | ] } � | k Vq d S( N( ( R t s( t string_to_search_for( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pys <genexpr>� s ( RZ ( R� t list_to_search( ( R� s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt substr_in_list� s c C@ sT t | t � rP x: | D]2 } t | t � rD t | � d k rH t Sq t Sq Wt St S( uy
Returns True if data is a list of one-element dicts (as found in many SLS
schemas), otherwise returns False
i ( R RD R! R R RS ( R4 t element( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt is_dictlist� s
c C@ s t | t j � r^ y t j j j | � } Wq^ t j j j j k
rZ } t j
| � i SXn | d k rv d � } n | d k r� d � } n t j t j t
f } t | t � r'x� | D]g } t | | � r� q� q� t | t � r t | � d k r t j
d | � i Sq� t j
d | � i Sq� Wn t j
d | � i Si } x� | D]� } t | | � rpd | | | � <qHt t | � � } | | }
t |
� r�| r�t |
d | �| | | � <q | r�t j
d � i S| | |
� | | | � <qH| | |
� | | | � <qHW| S(
ut
Takes a list of one-element dicts (as found in many SLS schemas) and
repacks into a single dictionary.
c S@ s | S( N( ( R| ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt <lambda> s c S@ s | S( N( ( R| t y( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR� s i uc Invalid input for repack_dictlist: key/value pairs must contain only one element (data passed: %s).uP Invalid input for repack_dictlist: element %s is not a string/dict/numeric valueuA Invalid input for repack_dictlist, data passed is not a list (%s)t recurseuU Invalid input for repack_dictlist: nested dictlist found, but recurse is set to FalseN( R R
Rd R> R? t yamlt safe_loadt parsert ParserErrorR� R� R- t
integer_typest floatRD R! R t nextR] R� t repack_dictlist( R4 t strictR� t key_cbt val_cbt errt valid_non_dictR� R; R R( ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR� � sZ
u is_listc C@ s
t | t � S( u(
Check if a variable is a list.
( R RD ( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt is_list9 s u is_iterc C@ sD | r t | | � r t Sy t | � t SWn t k
r? t SXd S( u�
Test if an object is iterable, but not a string type.
Test if an object is an iterator or is iterable itself. By default this
does not return True for string objects.
The `ignore` argument defaults to a list of string types that are not
considered iterable. This can be used to also exclude things like
dictionaries or named tuples.
Based on https://bitbucket.org/petershinners/yter
N( R R R] RS RH ( R� t ignore( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt is_iterA s
u sorted_ignorecasec C@ s t | d d � �S( u�
Sort a list of strings ignoring case.
>>> L = ['foo', 'Foo', 'bar', 'Bar']
>>> sorted(L)
['Bar', 'Foo', 'bar', 'foo']
>>> sorted(L, key=lambda x: x.lower())
['bar', 'Bar', 'foo', 'Foo']
>>>
R c S@ s
| j � S( N( R� ( R| ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR� e s ( t sorted( t to_sort( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt sorted_ignorecaseY s c C@ s� y t | � } Wn t t f k
r) n Xy t | � } Wn t t f k
rS n Xt | t j t f � rv | d k St | t j � r� t j | � j � d k St
| � Sd S( u
Returns a boolean value representing the "truth" of the value passed. The
rules for what is a "True" value are:
1. Integer/float values greater than 0
2. The string values "True" and "true"
3. Any object for which bool(obj) returns True
i u trueN( R} R~ RH R� R R
R� Rd Re R� t bool( R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt is_trueh s
u
mysql_to_dictc
C@ s i } d g } x� | D]� } | s( q n | j d � r= q n | j d � } x. t t | � � D] } | | j � | | <q_ Wt | � d k r t | � d } i } xG t | � D]9 } | d k r� q� q� t j j j | | � | | | <q� W| | | | <q | } q W| S( u;
Convert MySQL-style output to a python dictionary
u u +u |i ( R� Rv R R t stripR> R? R@ t to_num(
R4 R R; t headerst linet compst compt indext rowt field( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt
mysql_to_dict� s(
%
c C@ s� | d k r | St j t j t j t t f } t t | � t t g � } t | t t f � r� g } xl | D]d } | d k r� t | t
t f � r� t | � } q� t | | � s� t | � } q� n | j
| � ql W| St | t
� r�i } x� t j | � D]� \ } } | d k r4t | | � r4t | � } n | d k rgt | t
t t f � rgt | � } n+ | d k r�t | | � r�t | � } n | | | <q� W| S| S( ug
Convert the data list, dictionary into simple types, i.e., int, float, string,
bool, etc.
N( R- R
Rd Re R� R� R� RF RD R R! t simple_types_filterR% RR R& ( R4 t simpletypes_keyst simpletypes_valuest simplearrayR t
simpledictR ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyR� � s4
$ c C@ s| g } xo | D]g } t j rC t | t � rC t j j j | � } n$ t | t j � sg t j | � } n | j
| � q
W| S( uu
Given an iterable, returns its items as a list, with any non-string items
converted to unicode strings.
( R
t PY2R t strR> R? R@ RA Rd Re RR ( R4 R; R ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt stringify� s
(C R, t
__future__R R R R) Rf t loggingR� t collections.abcR R R t ImportErrort collectionst salt.utils.dictupdateR> t salt.utils.stringutilst salt.utils.yamlt
salt.defaultsR t salt.exceptionsR t salt.utils.decorators.jinjaR t salt.utils.odictR t salt.extR
t salt.ext.six.movesR t getLoggerR* R� R R R. R R6 R- R< R= RP RC RE RG RY RT RU RV Ra Rb Ru R{ Rc R� R� R� R� R� Rd R� R� R� R� R� R� ( ( ( s3 /usr/lib/python2.7/site-packages/salt/utils/data.pyt <module> s�
4 9 9 & # 2 ! 2 , � B %
Mini Shell