o
    
p`                     @   s   d Z ddlZddlZddlmZ ddlmZmZmZ i Z	e
 ZejejedZdd Zdd	 Zd
d ZdddZdd ZG dd deZG dd dejZdS )aG  
    babel.localedata
    ~~~~~~~~~~~~~~~~

    Low-level locale data access.

    :note: The `Locale` class, which uses this module under the hood, provides a
           more convenient interface for accessing the locale data.

    :copyright: (c) 2013-2019 by the Babel Team.
    :license: BSD, see LICENSE for more details.
    N)chain)picklestring_typesabczlocale-datac                 C   sL   | rt | ts	dS |   } ttt gD ]}| | kr#|  S qdS )zNormalize a locale ID by stripping spaces and apply proper casing.

    Returns the normalized locale ID string or `None` if the ID is not
    recognized.
    N)
isinstancer   striplowerr   from_iterable_cachelocale_identifiers)name	locale_id r   2/usr/lib/python3/dist-packages/babel/localedata.pynormalize_locale   s   r   c                 C   sX   | rt | ts	dS tj| } | tv rdS tjtjtd|  }|r&dS t	t
| S )zCheck whether locale data is available for the given locale.

    Returns `True` if it exists, `False` otherwise.

    :param name: the locale identifier string
    FT%s.dat)r   r   ospathbasenamer
   existsjoin_dirnameboolr   )r   
file_foundr   r   r   r   )   s   r   c                  C   s<   t tdd} | du rdd dd ttD D  t_} | S )a  Return a list of all locale identifiers for which locale data is
    available.

    This data is cached after the first invocation in `locale_identifiers.cache`.

    Removing the `locale_identifiers.cache` attribute or setting it to `None`
    will cause this function to re-read the list from disk.

    .. versionadded:: 0.8.1

    :return: a list of locale identifiers (strings)
    cacheNc                 S   s$   g | ]\}}|d kr|dkr|qS )z.datrootr   ).0stem	extensionr   r   r   
<listcomp>H   s    z&locale_identifiers.<locals>.<listcomp>c                 s   s    | ]	}t j|V  qd S N)r   r   splitext)r   filenamer   r   r   	<genexpr>K   s    z%locale_identifiers.<locals>.<genexpr>)getattrr   r   listdirr   r   )datar   r   r   r   9   s   r   Tc                 C   s  t j| } t  zyt| }|s}| dks|si }n,ddlm} |d| }|sA| 	d}t
|dkr8d}n	d|dd }t| }t jtd	|  }t|d
}| dkre|ret|t| nt|}W d   n1 stw   Y  |t| < |W t  S t  w )ae  Load the locale data for the given locale.

    The locale data is a dictionary that contains much of the data defined by
    the Common Locale Data Repository (CLDR). This data is stored as a
    collection of pickle files inside the ``babel`` package.

    >>> d = load('en_US')
    >>> d['languages']['sv']
    u'Swedish'

    Note that the results are cached, and subsequent requests for the same
    locale return the same dictionary:

    >>> d1 = load('en_US')
    >>> d2 = load('en_US')
    >>> d1 is d2
    True

    :param name: the locale identifier string (or "root")
    :param merge_inherited: whether the inherited data should be merged into
                            the data of the requested locale
    :raise `IOError`: if no locale data file is found for the given locale
                      identifer, or one of the locales it inherits from
    r   r   )
get_globalparent_exceptions_   Nr   rb)r   r   r   _cache_lockacquirer
   get
babel.corer'   splitlenr   loadcopyr   openmerger   release)r   merge_inheritedr&   r'   parentpartsr"   fileobjr   r   r   r3   Q   s2   


r3   c                 C   s   |  D ]I\}}|durM| |}t|trG|du ri }t|tr&||f}n#t|tr=|\}}| }t|| ||f}n| }t|| n|}|| |< qdS )an  Merge the data from `dict2` into the `dict1` dictionary, making copies
    of nested dictionaries.

    >>> d = {1: 'foo', 3: 'baz'}
    >>> merge(d, {1: 'Foo', 2: 'Bar'})
    >>> sorted(d.items())
    [(1, 'Foo'), (2, 'Bar'), (3, 'baz')]

    :param dict1: the dictionary to merge into
    :param dict2: the dictionary containing the data that should be merged
    N)itemsr/   r   dictAliastupler4   r6   )dict1dict2keyval2val1aliasothersr   r   r   r6      s&   






r6   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	r>   zRepresentation of an alias in the locale data.

    An alias is a value that refers to some other part of the locale data,
    as specified by the `keys`.
    c                 C   s   t || _d S r    )r?   keys)selfrG   r   r   r   __init__      zAlias.__init__c                 C   s   dt | j| jf S )Nz<%s %r>)type__name__rG   rH   r   r   r   __repr__      zAlias.__repr__c                 C   sP   |}| j D ]}|| }qt|tr||}|S t|tr&|\}}||}|S )zResolve the alias based on the given data.

        This is done recursively, so if one alias resolves to a second alias,
        that second alias will also be resolved.

        :param data: the locale data
        :type data: `dict`
        )rG   r   r>   resolver?   )rH   r&   baserB   rE   rF   r   r   r   rP      s   	





zAlias.resolveN)rL   
__module____qualname____doc__rI   rN   rP   r   r   r   r   r>      s
    r>   c                   @   sJ   e Zd ZdZdddZdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dS )LocaleDataDictzUDictionary wrapper that automatically resolves aliases to the actual
    values.
    Nc                 C   s   || _ |d u r	|}|| _d S r    )_datarQ   )rH   r&   rQ   r   r   r   rI      s   
zLocaleDataDict.__init__c                 C   
   t | jS r    )r2   rV   rM   r   r   r   __len__      
zLocaleDataDict.__len__c                 C   rW   r    )iterrV   rM   r   r   r   __iter__   rY   zLocaleDataDict.__iter__c                 C   s   | j |  }}t|tr|| j}t|tr(|\}}|| j }t|| t|t	u r5t
|| jd}||ur>|| j |< |S N)rQ   )rV   r   r>   rP   rQ   r?   r4   r6   rK   r=   rU   )rH   rB   origvalrE   rF   r   r   r   __getitem__   s   



zLocaleDataDict.__getitem__c                 C   s   || j |< d S r    rV   )rH   rB   valuer   r   r   __setitem__   rJ   zLocaleDataDict.__setitem__c                 C   s   | j |= d S r    r`   )rH   rB   r   r   r   __delitem__   s   zLocaleDataDict.__delitem__c                 C   s   t | j | jdS r\   )rU   rV   r4   rQ   rM   r   r   r   r4      rO   zLocaleDataDict.copyr    )rL   rR   rS   rT   rI   rX   r[   r_   rb   rc   r4   r   r   r   r   rU      s    
rU   )T)rT   r   	threading	itertoolsr   babel._compatr   r   r   r
   RLockr-   r   r   dirname__file__r   r   r   r   r3   r6   objectr>   MutableMappingrU   r   r   r   r   <module>   s   
7!!